Self-Supervised Contextual Bandits in Computer Vision

03/18/2020 ∙ by Aniket Anand Deshmukh, et al. ∙ University of Michigan 0

Contextual bandits are a common problem faced by machine learning practitioners in domains as diverse as hypothesis testing to product recommendations. There have been a lot of approaches in exploiting rich data representations for contextual bandit problems with varying degree of success. Self-supervised learning is a promising approach to find rich data representations without explicit labels. In a typical self-supervised learning scheme, the primary task is defined by the problem objective (e.g. clustering, classification, embedding generation etc.) and the secondary task is defined by the self-supervision objective (e.g. rotation prediction, words in neighborhood, colorization, etc.). In the usual self-supervision, we learn implicit labels from the training data for a secondary task. However, in the contextual bandit setting, we don't have the advantage of getting implicit labels due to lack of data in the initial phase of learning. We provide a novel approach to tackle this issue by combining a contextual bandit objective with a self supervision objective. By augmenting contextual bandit learning with self-supervision we get a better cumulative reward. Our results on eight popular computer vision datasets show substantial gains in cumulative reward. We provide cases where the proposed scheme doesn't perform optimally and give alternative methods for better learning in these cases.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 10

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Allocating limited resources between competing choices when the choice attributes are only partially available or not available is a classic multi-armed bandit problem. For example: choosing an ad to display out of many possible ads given a user visit to a website, or recommending a news article out of many possible articles to a visiting reader. For choosing an ad to display, we only have partial labels even when a user clicks on the displayed ad since we don’t observe whether the user would have clicked or not on non-displayed ads. The system needs to decide between displaying the current best performing set of ads (exploitation) and trying to discover new ads that can perform as well or better (exploration). Multi-armed bandit settings occur naturally in sequential decision process like these where there is an explore and exploit trade off. Traditionally a multi-armed bandit problem is solved using -greedy [Tokic_10_1007], UCB based [pmlr-v22-kaufmann12]

, Thompson Sampling (or Bayesian methods) 

[agrawal2013thompson, riquelme2018deep], bootstrap based approach [kveton2019garbage], exp4-type approach [McMahan_35401] etc. All of these methods have a combination of explore and exploit phases in the algorithm with varying degree of exploration and exploitation.

Compared to multi-armed bandits, the contextual bandit setting has features that define the context of each action or arm. Contextual bandits are one of the most common bandit settings encountered in real world. E.g. recommending an ad or a news article to a user has features such as demography, location, webpage metadata etc. An ad (or arm) to be chosen for serving in order to obtain a click (or reward) will be based on these features (or context). The bandit reward to be optimized in this case will be a function of these features. This is the underlying principal of many of the contextual bandit solvers such as LinUCB [chu2011contextual], KernelUCB [kveton2019garbage], Thompson sampling [agrawal2013thompson] etc. The contextual bandit setting also solves the cold start problem quite prevalent in recommendation engines [li2016collaborative]. In case of a new user without history, the bandit approach is to initially rely more on the exploration phase. This simple approach results in relatively good gains.

Representation learning in contextual bandits setting has been studied in recent times via the use of deep neural networks 

[riquelme2018deep]. A good feature representation learning can lead to good gains in reward optimization in bandit tasks. [riquelme2018deep]

shows that using neural network with Bayesian linear regression as the top layer helps contextual bandits setting learn good representations. This in turn leads to better bandit reward optimization. Self-supervision is another approach for learning good feature representation for machine learning tasks 

[dosovitskiy2015discriminative, gidaris2018unsupervised, noroozi2016unsupervised, zhang2016colorful, goyal2019scaling, pathak2017curiosity, burda2018large, pathak2019self]. Given the label scarcity issue faced by machine learning practitioners, self-supervision has been used as one of the primary methods to leverage unlabeled data for supervised machine learning problems [dosovitskiy2015discriminative, gidaris2018unsupervised, noroozi2016unsupervised, zhang2016colorful]. Self-supervised learning combines unlabeled data with implicit labeling [mikolov2013efficient] to find rich feature representations [saunshi2019theoretical]. The richer representations help in the overall supervised or unsupervised task at hand. Self-supervised approaches have led to remarkable gains in label scarce tasks—image recognition  [taha2018stream, Singh2018SelfSupervisedFL], clustering [Caron_2018_ECCV], classification [10.1145/1645953.1646072], few-shot learning [Gidaris_2019_ICCV]

, semi-supervised learning 

[rebuffi2019semisupervised], learning to rank [pami/LiuWB19] etc. Self-supervised learning is a promising approach to solving the label scarcity issue especially if the input space has good representational structure.

UCB (upper confidence bound) based contextual bandit solvers select arms that maximize an acquisition function which is based on an estimated UCB of the reward. LinUCB finds a linear relationship between the current expected reward of an arm and all its previous rewards. The feature vectors in current round are reformulated as a linear combination of feature vectors in previous rounds. These computed linear weights and rewards in the previous rounds are used to compute the reward in the current round 

[chu2011contextual]. Rather than use a linear model, nonlinear methods may be used that extend the LinUCB approach by finding a non-linear weight combination using a deep neural network—we call this Neural-UCB.

In this work we combine Neural-UCB with self-supervised learning to utilize the rich representation extracted by self-supervision. The self supervision helps by finding better feature representations given that the data labels are scarce for bandits setting especially in the exploration phase. We demonstrate the effectiveness of this combination on image classification dataset in a contextual bandits setting. Image ads are a common ad entity. Image ads recommendation tasks subsume image classification task since an ad-recommendation engine has to know the content of the image in the ad before showing it to the user. We convert the image classification problem into a contextual multi-arm bandits problem by passing sequence of images to a bandits setting and rewarding it for guessing the correct label (max-reward action or pulling the correct arm of the bandit) of the image. Our primary contributions are:

  • We propose a novel technique to combine self-supervision with contextual bandits objective that provides good gains in the cumulative reward optimization. This is the first ever technique proposed for leveraging representation learning (via self-supervision) in contextual bandits task, as far as the authors know.

  • We analyze the proposed method over eight diverse real world datasets showing good empirical gains across multiple random runs of the proposed algorithm.

  • We empirically show the substantial benefits of self-supervision and scenarios where it helps the most in contextual bandits setting.

2 Motivation

The multi-armed bandit setting suffers from data and label scarcity (or limited feedback) issues especially in the initial phase of the algorithm. In this phase, exploration is more prominent than exploitation, as the model needs more labels and data for accurate predictions. Recently self-supervision techniques have shown remarkable accuracy improvements in supervised and unsupervised label scarce tasks [taha2018stream, Singh2018SelfSupervisedFL, Caron_2018_ECCV, 10.1145/1645953.1646072, Gidaris_2019_ICCV, rebuffi2019semisupervised, pami/LiuWB19]. The gains in self-supervision primarily come from extracting a better feature representation of the data using implicit labels. It has been shown that good representation learning can help multi-armed bandits setting [riquelme2018deep]. Our aim is to help contextual bandits’ data and label scarcity issue by leveraging self-supervision scheme in getting better feature representation of the data.

We drive the effectiveness self-supervision in contextual bandits setting via demonstrating its superior performance in sequential image classification. Contextual bandits are a common approach for solving ads recommendation as they alleviate the cold start issue that the recommendation task suffers from [li2016collaborative]. Image ads are a common ad type where image classification is an important sub-task of image ad recommendation. An image ad recommendation system needs to know the semantic content of an image ad. In this work, we formulate image classification in a contextual bandits setting. The contextual bandit is provided a sequence of images and predicting the correct class (equivalent to pulling the most rewarding arm) leads to a reward of 1 otherwise 0. In this problem setting, we demonstrate the effectiveness of augmenting contextual bandits solver with self-supervised scheme to improve cumulative rewards optimization. We demonstrate the effectiveness of rich feature representations extracted via self-supervision in solving contextual bandits tasks.

3 Contextual Bandits and Self-Supervision

for  do
       Observe context for all arms , where Choose an arm Receive a reward Improve arm selection strategy based on new observation
Goal: Maximize cumulative reward :=
Algorithm 1 Contextual Bandits Problem

Contextual Bandits are a class of bandit algorithms wherein, at round , each arm is associated with a context . In such problems, rewards are assumed dependent on these observed covariates, which allow for conditional modelling of the reward, that is, estimation of

. As in multi-armed bandits, contextual bandits are used for situations where standard supervised learning methods may be asymptotically suboptimal by failing to explore optimal arms enough. This exploration is typically related to (estimates of) the variance of the estimator

.

Due to the conditional dependence on , some assumptions about are required in order to expect a vanishing uncertainty over time, so that the bandit algorithm can enter an exploitation phase and achieve sublinear regret. One such assumption is a linear assumption on the relationship between and as in LinUCB [chu2011contextual]. Bandit algorithms with nonlinear dependencies include GP-UCB [srinivas2010gaussian] and KernelUCB [valko2013finite], which assume dependencies drawn from Gaussian Process, or lying in a Reproducing Kernel Hilbert Space, respectively. These three methods utilize the Upper Confidence Bound (UCB) as the means of uncertainty quantification for the purposes of trading off between exploration and exploitation. Other methods for handling uncertainty can be used in contextual bandits, for example Thompson Sampling [agrawal2013thompson] and the Bootstrapping [kveton2019garbage]. Algorithm 1 illustrates our contextual bandit setting and the goal is to maximizing the cumulative reward.

Contextual bandits have been used extensively in sequential decision making tasks. [li2011unbiased] elaborates an evaluation scheme for contextual bandits based recommendation engines. [li2016collaborative] proposes a contextual bandits based dynamic clustering approach to collaborative filtering that reduces the effect of classic cold-start problem using explore and exploit scheme. It shows good gains on diverse set of recommendation task datasets. [tewari2017ads] provides modifications needed in contextual bandit settings to adapt it for mobile health tasks. [deshmukh2018simple] devises a scheme where the bandit solver, called Contextual-Gap algorithm, has a pure exploration phase (feedback received but no regrets incurred) and a pure exploitation phase (regret incurred but no feedback). The Contextual-Gap algorithm shows good gains in regret minimization for adaptive sensor selection for magnetic field estimation in interplanetary spacecraft.

Get the unsupervised data Build a self-supervised task Learn representation of original data using defined self-supervised task Use the learnt representation for downstream tasks
Algorithm 2 Standard Self-Supervised Learning Problem

We combine algorithm 1 with self-supervision to help the data scarcity issues as mentioned earlier. Given correct model specification and enough labelled data, supervised learning methods supply decent performance on the task. The core idea of self-supervision is to create an auxiliary task for which one can easily generate labels and then train a model on this supervised auxiliary task. Traditionally, after the model is trained on auxiliary (self-supervised) task, we use trained model as a feature extractor and train a linear predictor for the final machine learning task as illustrated in algorithm 2. Although summarizing all self-supervised methods is beyond the scope of this paper, we will briefly summarize some of them in order to present generic idea of self-supervision. For all these methods, we will assume that a seed data set is given.Exemplar CNN [dosovitskiy2015discriminative]: For a subset of of size , first generate patches of a predefined size and then apply

different transformations to these patches. The self-supervised task is to classify transformed images in to

classes. Rotation [gidaris2018unsupervised]: Each image in is rotated by and degrees i.e. multiples of degrees. The self-supervised task is to classify rotated images in to classes. Jigsaw Puzzle [noroozi2016unsupervised]: An image is divided in to 9 regions by using grid and these regions are shuffled. The self-supervised task is to predict the correct location of each region given the shuffled regions.

Self-supervised learning methods have also been used in reinforcement learning (RL) settings 

[pathak2017curiosity, burda2018large, pathak2019self]. One of the state-of-the art methods in RL is using self-supervision to increase the exploration of unpredictable states given the current state [pathak2017curiosity, burda2018large]. Another prominent method is to train a set of agents and explore the states with maximum disagreement [pathak2019self]. Self-supervision in RL leverages the fact that representation learning can lead to predicting next state given the current state which is not the case in contextual bandits. Hence, self-supervised methods show impressive performance on supervised learning tasks and improve the state of the art in RL settings, it is not obvious whether they can be used in contextual bandit settings directly.

Input: Input:
Initialize: , and for each for  do
       Observe context features at time : for each . for all at time  do
            
       Choose arm , observe a real valued payoff and update . Update Update Update Output: Output:
      
Algorithm 3 Lin-UCB
Input: Input:
Initialize: , and for each Initialize: Neural Network for  do
       Observe context features at time : for each . Get representation of context features at time using neural network for each . for all at time  do
            
       Choose arm , observe a real valued payoff and update . Update history if   then
             Retrain Neural Network using history to get
      else
            
      Update Update Update Output: Output:
      
Algorithm 4 Neural-UCB

4 Proposed Method

We first describe the existing contextual bandit solvers, specifically, Lin-UCB and Neural-UCB. Later, we elaborate the proposed approach of combining self-supervision and contextual bandits, SS-Neural-UCB. We do not add self-supervision to Lin-UCB as Lin-UCB does not leverage feature representation learning as is the case with Neural-UCB.

Lin-UCB:

The Lin-UCB, algorithm 3, assumes a linear model for the reward: . One benefit of this approach is that the linear least squares (LLS) estimates may be constructed in an online fashion. Specifically, recall that the LLS estimator for design matrix and response vector is:

(1)

By performing an online update for and rank-one updates of a scatter matrix , estimates for each arm may be efficiently updated when observing new data. Furthermore, the LLS perspective allows one to estimate the variance of the predicted reward at a particular context as:

(2)

Here is the variance of the (assumed homoscedastic) noise, and can be derived from the fact that is a maximum likelihood estimator (and thus asymptotically efficient) and its variance is inversely related to the Fisher information.

This estimated variance is then used to construct an upper confidence bound (UCB) for each arm, and the arm is chosen by maximizing the UCB – see Algorithm 3.

Neural-UCB:

The Neural-UCB, algorithm 4, operates in a similar to Lin-UCB, except that a nonlinear model is used to construct an intermediate representation for the context . This representation of the context is then used in place of the real in Lin-UCB for estimation of and its variance. Note that the full history is retained for training . Introducing the nonlinear layer gives the bandit algorithm the additional flexibility required to model arbitrarily complex tasks while still doing trade off between exploration and exploitation.

4.1 SS-Neural-UCB (Proposed Method)

The nonlinear mapping learnt by Neural-UCB is critical to the performance of the bandit algorithm. In the early stages of training, these complex representations may not see enough data in order to produce good predictions. This either leads to suboptimal performance, or requires careful tuning of learning rates and regularization decay. One successful approach in computer vision for learning complex and useful representations from limited data is self-supervision (see Section 3) which we propose to leverage in training Neural-UCB bandit algorithms. Our proposed bandit algorithm (algorithm 5) combines the bandit loss with self-supervised loss:

(3)

where is the bandits loss (least squares), is the self-supervised loss (auxiliary task loss), is the weight on self-supervised loss and is the time step. We are decaying the weight given to self-supervision since the bandits setting needs more guidance in the beginning phases (dominated by exploration and data scarcity). In case of , the weight on self-supervised loss never goes to zero and in that case self-supervised loss may give sub-optimal performance on the original bandit task, as after sufficient rounds the network model has enough data to learn good representations. We show experimental results for in appendix.

Input: Input:
Initialize: , and for each Initialize: Neural Network and define a self-supervised task for  do
       Observe context features at time : for each . Get representation of context features at time using neural network for each . for all at time  do
            
       Choose arm , observe a real valued payoff and update . Update history if   then
             Retrain Neural Network using history and self-supervised task to get
      else
            
      Update Update Update Output: Output:
      
Algorithm 5 SS-Neural-UCB
#Rep Image Size
MNIST 60000 10 10
F-MNIST 60000 10 10
CIFAR-10 50000 10 10
CINIC-10 50000 10 10
STL-10 5000 10 10
Intel 14000 6 10
Food-10 10000 10 10
Imagenet-10 13000 10 10
Table 1: denotes the number of examples used for a contextual bandit problem, and the number of actions (classes in this case) in a given dataset; and #Rep the number of repetitions with different initializations/seeds.

5 Experiments

Contextual bandit settings are very common in ad recommendations as the user visits the webpage. Image ads are a common ad type and image classification is essential for such ad recommendations. We evaluate contextual bandits algorithm on image classification datasets. Converting multiclass classification datasets to bandits setup is a common way of evaluation in contextual bandits community because of lack of datasets with bandit feedback [deshmukh2017multi, riquelme2018deep]. Each class in multiclass classification is considered as an arm or action. At every time step (iteration) , agent is shown a feature vector and the goal of agent is to recommend an arm (class) for that feature vector. If the agent predicts the arm (class label) correctly then it gets rewarded and if it predicts wrong it gets no reward. In this work, we focus on image classification because the primary aim is to get good feature representation in bandit tasks. For the self-supervision, the auxiliary task is rotation as defined in [gidaris2018unsupervised].

5.1 Datasets

We use MNIST [lecun1998gradient], Fashion-MNIST (F-MNIST) [xiao2017/online], CIFAR-10 [krizhevsky2009learning], CINIC-10 [darlow2018cinic], STL-10 [coates2011analysis], Intel [intel], Food-10 [bossard2014food], and Imagenet-10 [krizhevsky2012imagenet] datasets to demonstrate the effectiveness of the method proposed. For MNIST and F-MNIST, we use all of the 60000 training examples. For CIFAR-10 and STL-10 we use all of the 50000 and 5000 training examples respectively. For CINIC-10, we randomly samply 50000 examples for each run from 90000 available training examples. For Food-10 and Imagenet-10, we select 10 classes out of 101 and 1000 classes in the original datasets respectively and then use all the training samples in those selected classes. For Intel dataset we use all of the 14000 training examples. Note that, in bandits setting there is no distinction made between training and test phase of the learning which is the case in traditional machine learning. In the table below 1, we provide the details of the datasets used. As noted in the table, we use ten random seeds and number of arms (classes). Using ten different random seeds leads to different sequence of images shown to the bandit solver in each of the ten different runs.

MNIST contains images of numerical digits that are to be classified in their semantic number class (). F-MNIST contains images of ten human dress types (classes) such as trouser, pullover, etc which are to be classified into their corresponding class labels. CIFAR-10, CINIC-10 and STL-10 contain images of animate (bird, car, deer, etc) and inanimate (airplane, truck, etc) objects that are classified into their respective class labels given an image. Intel image classification dataset has images of natural scenes around the world such as buildings, forest, glaciers, etc. Images from these scenes are classified into their class label given an image from this data. Food-10 is a subset of original food-101 dataset [bossard2014food], where we randomly selected 10 classes out of the 101 classes for the classification task. The food-101 dataset contains images of 101 kinds of food that are to be classified to their corresponding class label given a food image. The selected classes are: Apple pie, Carrot cake, Chicken curry, Clam chowder, Falafel, Ice cream, Garlic bread, Mussels, Panckaes, Takoyaki. Imagenet-10 is a collection of ten randomly selected classes from the original Imagenet data with 1000 classes. The selected classes are: Stingray, Thunder snake, Oystercatcher, Beaver, Baseball, Shower curtain, Toyshop, Trailer truck, Strawberry and Bubble.

MNIST and F-MNIST are grey scale images. CIFAR-10, CINIC-10, STL-10, Intel, Food-10, and Imagenet-10 are all colored images. MNIST and F-MNIST are relatively larger datasets (60000 images) compared to CIFAR-10, CINIC-10, STL-10, Intel, Food-10, and Imagenet-10. The original MNIST and F-MNIST are pixels whereas CIFAR-10, CINIC-10 are pixels. STL-10 images contain pixels, Intel images contain pixels, Food-10 images contain pixels, and Imagenet images contain pixels per image. Apart from MNIST and F-MNIST, images from other datasets were resized to . We observe that images from MNIST and F-MNIST have a simpler representation in terms of structure in the images compared to Imagenet or CIFAR-10 images. This inherent structure is exploited well by the self-supervision scheme proposed as we will observe in results section later.

5.2 Neural Network Implementation

Figure 1: Neural network block diagram for self-supervised contextual bandits

MNIST and F-MNIST use two layer convolutional neural network (CNN) and other datasets use Alexnet. Figure

1

shows a block diagram of the implementation. We use PyTorch for the neural network implementation. For MNIST and F-MNIST, we use stochastic gradient descent (SGD) with learning rate 0.25. For all other datasets we use Adam with learning rate 0.001. At the start of the experiment we pull each arm once to initialize the bandit problem as done traditionally

[riquelme2018deep, deshmukh2017multi]

. We retrain the neural network for 10 epochs after every 500th arm-selection round (in Algorithm

5, ). For all algorithms, we use and . MNIST, F-MNIST and CIFAR-10 use self-supervised loss weight and CINIC-10, Food-10, Intel, STL-10, and Imagenet-10 use self-supervised loss weight .

[] []

[] []

[] []

[] []

Figure 2: Cumulative Reward plots

6 Results

The overall results on all eight datasets are plotted and tabulated in Figure 2 and Table 2, respectively. All the plots shown in Figure 2

are averaged over ten random seed runs. The standard deviation of these results are reported in Table 

2 for each dataset and each approach. SS-Neural-UCB (Neural-UCB with self-supervision) outperforms all other methods across all eight datasets with wide margins in terms of rewards obtained. In the plots for MNIST and F-MNIST datasets (figure 2, and figure 2 respectively) we can clearly see that the SS-Neural-UCB peforms the best in terms of rewards over iterations (timesteps ) followed by Neural-UCB and Lin-UCB. The difference becomes more prominent with the increase in number of steps since the reward prediction becomes better as better feature representations are learnt over time.

LinUCB NeuralUCB SSNeuralUCB
MNIST 46444.8 ( 141.33) 53404.2 (219.55) 54395.2 ( 129.50)
F-MNIST 41036.0 ( 136.14) 46467.5 ( 278.39) 47800.6 ( 113.64)
CIFAR-10 9567.4 ( 108.35) 9227.8 ( 1950.52) 14278.0 ( 396.80)
CINIC-10 7560.1 ( 72.88) 8449.7 ( 951.46) 12346.7 ( 418.38)
STL-10 548.5 ( 19.10) 621.1 ( 52.47) 777.1 ( 42.7)
Intel 3571.5 ( 124.51) 7136.2 ( 226.90) 7178.8 ( 1285.44)
Food-10 1151.4 (40.71) 1533.0 ( 91.1) 1823.1 ( 56.13)
Imagenet-10 1870.8 ( 45.21) 3705.5 ( 259.11) 4021.4 ( 726.32)
Table 2: Mean cumulative reward for all eight datatsets over ten random seed runs—standard deviation reported in brackets. Higher mean and lower standard deviation is better.
Lin-UCB Neural-UCB SS-Neural-UCB
MNIST 0 0 10
F-MNIST 0 0 10
CIFAR-10 0 0 10
CINIC-10 0 0 10
STL-10 0 0 10
Intel 0 2 8
Food-10 0 0 10
Imagenet-10 0 1 9
Table 3: Number of times each of the algorithm was ranked top in terms of cumulative reward
Dataset Gain by SS-Neural-UCB (in %)
MNIST 1.86
F-MNIST 2.87
CIFAR-10 54.7
CINIC-10 46.11
STL-10 24.1
Intel 0.50
Food-10 18.92
Imagenet-10 8.53
Table 4: Absolute percentage gain in cumulative rewards by SS-Neural-UCB over the next best bandits solver (Neural-UCB).

6.1 Benefits of Self-Supervision

Figures 222, and 2 show the reward vs timesteps plots for STL-10, Imagenet-10, CIFAR-10, and Food-10 datasets. Similar to MNIST and F-MNIST results we see the SS-Neural-UCB outperforms all other methods. Additionally, the performance gap between best (SS-Neural-UCB) and the second best method (Neural-UCB) gets wider as timesteps increase. This can be explained by our earlier assertion that STL-10, Imagenet-10, CINIC-10, CIFAR-10, and Food-10 images have more complex representations. The self-supervision, by extracting these rich feature representations, helps the bandit solver achieve better reward prediction. STL-10, Food-10, and Imagenet-10 plots (figures 22, and 2) show that even with fewer timesteps, i.e. fewer datapoints in bandit learning (5000 or less), the SS-Neural-UCB is able to outperform all the other methods. This shows that self-supervision is learning good feature representation despite the usual lack of datapoints in the early phases of bandit solvers. This is an important attribute of this learning scheme as this helps to reach the optimal policy quickly.

[]

[] []

Figure 3: Cumulative Reward plots for three out of eighty cases in the main results where proposed method SS-Neural-UCB is not the best method.

6.2 Overall Performance

Table 3 tabulates statistics of the overall performance of the three bandit solvers over all eight datasets. It provides the number of times SS-Neural-UCB outperforms its competition across the eight different datasets and the ten random seed runs . We see that for all except two datasets, Intel and Imagenet, SS-Neural-UCB bests its closest second in all ten runs. For Intel dataset it performs better than the second best in eight trials whereas for Imagenet-10 it performs better in nine trials out of ten. Table 2 shows the mean cumulative rewards obtained by the methods on the eight datasets along with the standard deviation over the ten runs. We see that we are better in the cumulative reward means as well as standard deviations across all eight datasets except two—Intel and Imagenet-10. For Intel and Imagenet-10 we outperform in the cumulative reward means but not in the standard deviations. This case is also captured by the Table 3 wherein we fail to outperform for the three runs in the two datasets. Table 4 shows the absolute percentage gain by the top performing method, i.e. the proposed method SS-Neural-UCB, over it’s next best competitor (Neural-UCB). We can see that the gains obtained in datasets with rich structure (STL-10, Imagenet-10, CINIC-10, CIFAR-10, and Food-10) is quite high. The best performance comes on CIFAR-10 dataset (54% gain) closely followed by CINIC-10 dataset (46% gain).

6.3 Suboptimal Self-Supervision

As discussed earlier out of total eighty random seed runs (ten runs for each of the eight datasets), we fail to outperform the competing methods in three of them. Of these three cases, two belong to Intel dataset and one belongs to Imagenet-10, as shown in figure 3. SS-Neural-UCB starts degrading rapidly over timesteps for figures 3 and 3

. We suspect that few of the random seed runs lead to sequence of images in the beginning which is not a good sample of representation of overall dataset. This in turn leads to the self-supervision learning a bad representation in the beginning of the learning phase. Overall, this failure probability is very low: three out of eighty random runs i.e. less than 4%. This is remarkably good given the variety of image datasets the bandit solver has to work with—from clothes (F-MNIST) to sceneries (Intel) and dishes (Food-10) to wild animals (Imagenet-10). We provide more suboptimal cases by giving higher weights to the self-supervision loss in the appendix.

7 Conclusion

We observe significant gains in cumulative reward for contextual bandits by leveraging the rich representation extracted via self-supervision. Out of 80 runs across 8 tasks the combined proposed approach outperforms in 77 of them—a success rate above 96%. This is very promising given the diverse nature of image datasets. The insights gained from the results can lead to designing of bandit solvers that leverage true feature representation of the data leading to high gains in cumulative rewards. This is because the three failure cases are mostly due to the fact that we have a non representative sample sequence which forces self-supervision to learn sub-optimal feature representation.

The self-supervision starts helping from the get-go as seen in STL-10, Food-10, and Imagenet-10 plots (figures 22, and 2). This encourages practitioners to use self-supervision in bandits more since bandits are a slow learner due to the fact that feedback (data) is much more scarce in the beginning phases of learning. Which self-supervised tasks help under what bandit settings is a fruitful area of research. This can lead to further optimized solvers that can find optimal policy relative quickly.

8 Appendix

8.1 Too much Self-Supervision hurts

Note that if one does not reduce the weight of self-supervision loss with time (i.e. ), one gets very poor performance. The setting of is like a multi-task learning setting which is not really helpful in the case of contextual bandits. This fact is evident from the figures shown in 4

[] []

Figure 4: Cumulative Reward plots for failure cases when self supervised loss is not decreased with time

References