Contextual Active Model Selection

Introduction

As pre-trained models become increasingly prevalent in a variety of real-world machine learning applications [2,11,53], there is a growing demand for label-efficient approaches for model selection, especially when facing varying data distributions and contexts at run time. Oftentimes, no single pre-trained model achieves the best performance for every context, and a proper approach is to construct a policy for adaptively selecting models for specific contexts [48]. For instance, in medical diagnosis and drug discovery, accurate predictions are of paramount importance. The diagnosis of diseases through pathologist or the determination of compound chemical properties through lab testing can be costly and time-consuming. Different models may excel in analyzing different types of pathological images [1,3,23] or chemical compounds [17,32,46]. Furthermore, in many real-world applications, the collection of labels for model evaluation can be expensive and data instances may arrive as a stream rather than all at once. This scenario necessitates cost-effective and robust online algorithms capable of determining the most efficient model selection policy even when faced with a limited supply of labels, a scenario not fully addressed by previous works that typically assume access to all labels [6,7,27,54].

Recently, the problem of online model selection with the consideration of label acquisition costs was studied in a context-free setting by Karimi et al. [39]. However, this approach doesn't fully capture the dynamics of data contexts that are essential in many applications. Recognizing this gap, in this paper, we consider a more general problem setting that incorporates context information for adaptive model selection. We introduce CAMS, an algorithm for active model selection that dynamically adapts to the data context to choose the most suitable models for an arbitrary data stream. As highlighted in

Setup Algorithm Online bagging * Hedge EXP3 EXP4 Query by Committee ModelPicker CAMS [54] [ 27] [ 7] [ 7] [ 65] [ 39] (ours) bagging online learning bandit contextual bandits active learning model selection (ours) model selection †

† We regard "arms" as "models" when comparing CAMS against bandit algorithms, such as EXP3/EXP4. * Online ensemble learning aims to build a composite model by aggregating multiple models rather than selecting the best model (for a given context).

Table 1: Comparing CAMS against related work in terms of problem setup.

Table 1, CAMS aims to address the need for adaptive and effective model selection, by bridging the gap between contextual bandits, online learning, and active learning.

Our key contributions are summarized as follows:

• We investigate a novel problem which we refer to as contextual active model selection, and introduce a novel principled algorithm that features two key technical components: (1) a contextual online model selection procedure, designed to handle both stochastic and adversarial settings, and (2) an active query strategy. The proposed algorithm is designed to be robust to heterogeneous data streams, accommodating both stochastic and adversarial online data streaming scenarios.

• We provide rigorous theoretical analysis on the regret and query complexity of the proposed algorithms. We establish regret upper bounds for both adversarial and stochastic data streams under limited label costs. Our regret upper bounds are within constant factors of the existing lower bounds for online learning problems with expert advice under the full information setting.

• Empirically, we demonstrate the effectiveness and robustness of our approach on a variety of online model selection tasks spanning different application domains (from generic ML benchmarks such as CIFAR10 to domain-specific tasks in biomedical analysis), data scales (ranging from 80 to 10K), data modalities (i.e., tabular, image, and graph-based data), and label types (binary or multiclass labels). For the tasks evaluated, (1) CAMS outperforms all competing baselines by a significant margin.

(2) Asymptotically, CAMS performs no worse than the best single model. (3) CAMS is not only robust to adversarial data streams but also can efficiently recover from "malicious experts" (i.e. inferior pre-trained models).

Related Work

Contextual bandits. Classical bandit algorithms (e.g., [6,7]) aim to find the best arm(s) through a sequence of actions. When side information (e.g., user profile for recommender systems or environmental context for experimental design) is available, many bandit algorithms can be lifted to the contextual setting: For example, EXP4 [7,9,52] considers the bandit setting with expert advice: At each round, experts announce their predictions of which actions are the most promising for the given context, and the goal is to construct a expect selection policy that competes with the best expert from hindsight. In bandit problems, the learner only gets to observe the reward for each action taken. In contrast, for the online model selection problem considered in this work-where an action corresponds to choosing a model to make prediction on an incoming data point-we get to see the loss/reward of all models on the labeled data point. By utilizing the information from unchosen arms, it could significantly reduce the cumulative regret. In this regard, this work aligns more closely with online learning with full information setting, where the learner has access to the loss of all the arms at each round (e.g. as considered in the Hedge algorithm [13,14,27,36]).

Online learning with full information. A clear distinction between our work and online learning is that we assume the labels of the online data stream are not readily available but can be acquired at each round with a cost. In addition, the learner only observes the loss incurred by all models on a data point when it decides to query its label. In contrast, in the canonical online learning setting, labels arrive with the data and one gets to observe the loss of all candidate models at each round. Similar setting also applies to other online learning problems, such as online boosting or bagging. A related work to ours is online learning with label-efficient prediction [16], which proposes an online learning algorithm with matching upper and lower bounds on the regret. However, they consider a fixed query probability that leads to a linear query complexity. Our algorithm, inspired by uncertainty sampling in active learning, achieves an improved query complexity with the adaptive query strategy while maintaining a comparable regret.

Stream-based Active learning. Active learning aims to achieve a target learning performance with fewer training examples [64]. The active learning framework closest to our setting is queryby-committee (QBC) [65], in particular under the stream-based setting [35,47]. QBC maintains a committee of hypotheses; each committee member votes on the label of an instance, and the instances with the maximal disagreement among the committee are considered the most informative labels. Note that existing stream-based QBC algorithms are designed and analyzed assuming i.i.d. data streams. In comparison, our work uses a different query strategy as well as a novel model recommendation strategy, which also applies to the adversarial setting.

Active model selection. Active model selection captures a broad class of problems where model evaluations are expensive, either due to (1) the cost of evaluating (or "probing") a model, or (2) the cost of annotating a training example. Existing works under the former setting [49,59] and online setting [21,66] often ignore context information and data annotation cost, and only consider partial feedback on the models being evaluated/ probed on i.i.d. data. The goal is to identify the best model with as few model probes as possible. This is quite different from our problem setting which considers the full information setting as well as non-negligible data annotation cost. [71] proposes that the optimal model choice is influenced by the sample size rather than any individual sample feature. [44] addresses the active model selection problem, however both works do not adopt a stream-based approach. For the later, apart from Karimi et al. [39], an online contextual-free model selection work, as shown in Table 1, most existing works assume a pool-based setting where the learner can choose among the pool of unlabeled data [4,29,43,49,60,61,68,76], and the goal is to identify the best model with a minimal set of labels.

Problem Statement

Notations. Let X be the input domain and Y := {0, . . . , c ↑ 1} be the set of c possible class labels for each input instance. Let F = {f 1 , . . . , f k } be a set of k pre-trained classifiers over X → Y. A model selection policy ω : X ↓ ! k↑1 maps any input instance x ↔ X to a distribution over the pre-trained classifiers F, specifying the probability ω (x) of selecting each classifier under input x.

Here, ! k↑1 denotes the k-dimensional probability simplex w ↔ R k : |w| = 1, w ↗ 0 . One can interpret a policy ω as an "expert" that suggests which model to select for a given context x.

Let " be a collection of model selection policies. In this paper, we propose an extended policy set " → := " ↘ {ω const 1 , . . . , ω const k } which also includes constant policies that always suggest a fixed model. Here, ω const j (•) := e j , and e j ↔ ! k↑1 denotes the canonical basis vector with e j = 1. Unless otherwise specified, we assume " is finite with |"| = n, and |" → | ≃ n + k. As a special case, when " = ⇐, our problem reduces to the contextual-free setting.

The contextual active model selection protocol. Assume that the learner knows the set of classifiers F as well as the set of model selection policies ". At round t, the learner receives a data instance x t ↔ X as the context for the current round, and computes the predicted label ŷt,j = f j (x t ) for each pre-trained classifier indexed by j ↔ [k]. Denote the vector of predicted labels by all k models by ŷt := [ŷ t,1 , . . . , ŷt,k ] ↓ . Based on previous observations, the learner identifies a model/classifier f jt and makes a prediction ŷt,jt for the instance x t . Meanwhile, the learner can obtain the true label y t only if it decides to query x t . Upon observing y t , the learner incurs a query cost, and receives a (full) loss vector ε ε ε t = I {ŷ t ↔ =yt} , where the jth entry ε t,j := I {ŷt,j ↔ =yt} corresponds to the 0-1 loss for model j ↔ [k] at round t. The learner can then use the queried labels to adjust its model selection criterion for future rounds.

Performance metric. If x t is misclassified by the model j t selected by learner at round t, i.e. ŷt,jt ⇒ = y t , it will be counted towards the cumulative loss of the learner, regardless of the learner making a query. Otherwise, no loss will be incurred for that round. For a learning algorithm A, its cumulative loss over T rounds is defined as L A T := T t=1 ε t,jt . In practice, the choice of model j t at round t by the learner A could be random: For stochastic data streams where (x, y) arrives i.i.d., the learner may choose different models for different random realizations of (x t , y t ). For the adversarial setting where the data stream {(x t , y t )} t↗1 is chosen by an adversary before each round, the learner may randomize its choice of model to avoid a constant loss at each round [33]. Therefore, due to the randomness of L A T , we consider the expected cumulative loss E[L A T ] as a key performance measure of the learner A. To characterize the progress of A, we consider the regret-formally defined as follows-as the difference between the cumulative loss received by the learner and the loss if the learner selects the "best policy" ω → ↔ " → in hindsight. For stochastic data streams, we assume that each policy i recommends the most probable model w.r.t. ω i (x t ) for context x t . We use maxind(w) := arg max j:wj ↘w w j to denote the index of the maximalvalue entryfoot_1 of w. Since (x, y) are drawn i.i.d., we define µ i = 1 T T t=1 E xt,yt ε t,maxind(ωi(xt)) . This leads to the pseudo-regret for the stochastic setting over T rounds, defined as

In an adversarial setting, since the data stream (and hence the loss vector) is determined by an adversary, we consider the reference best policy to be the one that minimizes the loss on the adversarial data stream, and the expected regret

where εt,i := ⇑ω i (x t ) , ε ε ε t ⇓ denotes the expected loss if the learner commits to policy ω i , randomizes and selects j t ⇔ ω i (x t ) (and receives loss ε t,jt ) at round t. Our goal is to devise a principled online active model selection strategy to minimize the regret as defined in (1) or (2), while maintaining a low total query cost. For convenience, we refer the readers to App. B for a summary of the notations used in this paper.

Contextual Active Model Selection

In this section, we introduce our main algorithm for both stochastic and adversarial data streams.

1: Input: Models F, policies ", #rounds T , budget b 2: Initialize loss L0 ↖ 0; query cost C 0 ↖ 0 3: Set " → ↖ " ↘ {ω const 1 , . . . , ω const k } according to Eq. (3) 4: for t = 1, 2, ..., T do 5: Receive x t 6:

Output ŷt,jt ⇔ f t,jt as the prediction for x t 10:

Compute z t in Eq. (4)

11: Sample U t ⇔ Ber (z t ) 12: if U t = 1 and C t ≃ b then 13:

Query the label y t 14:

16: Estimate model loss: εt,j = εt,j zt , ∝j ↔ [|F|]

17: Update ε ε ε t : εt,i ↖ ⇑ω i (x t ), εt,j ⇓, ∝i ↔ [|" → |] 18: Lt = Lt↑1 + ε ε ε t 19: else 20: Lt = Lt↑1

21: C t ↖ C t↑1 22: end if 23: end for 21: procedure SETRATE(t, x t , m) 22: if STOCHASTIC then 23: ϑ t = ln m t 24: end if 25: if ADVERSARIAL then 26: Set ϖ t as in adversarial setting section 27:

end if

29: return ϑ t 30: end procedure 29: procedure RECOMMEND(x t , q t ) 30: if STOCHASTIC then 31:

32: j t ↖ maxind(w t ) 33: end if 34: if ADVERSARIAL then 35: i t ⇔ q t 36: j t ⇔ ω it (x t ) 37: end if 38: return j t 39: end procedure Our key insight underlying the contextual model selection strategy extends from the online learning with expert advice framework [13,27]. We start by appending the constant policies that always pick single pre-trained models to form the extended policy set " → (Line 3, in Fig. 1). This allows CAMS to be at least as competitive as the best model. Then, at each round, CAMS maintains a probability distribution over the (extended) policy set " → , and updates those according to the observed loss for each policy. We use q t := (q t,i ) i↘|! → | to denote the probability distribution over " → at t. Specifically, the probability q t,i is computed based on the exponentially weighted cumulative loss, i.e. q t,i ↙ exp ↑ϑ t Lt↑1,i where Lt,i := t ϖ =1 εϖ,i denotes the cumulative loss of policy i.

For adversarial data streams, it is natural for both the online learner and the model selection policies to randomize their actions to avoid linear regret [33]. Following this insight, CAMS randomly samples a policy i t ⇔ q t , and-based on the current context x t -samples a classifier j t ⇔ ω it (x t ) to recommend at round t.

Under the stochastic setting, CAMS adopts a weighted majority strategy [45] when selecting models. The vector of each model's weighted votes from the policies, w t = i↘|! → | q t,i ω i (x t ), is interpreted as a distribution induced by the weighted policy. The model j t = maxind(w t ) which receives the highest probability becomes the recommended model at round t. This deterministic model selection strategy is commonly used in stochastic online optimization [33]. An alternative strategy is to take a randomized approach as in the adversarial setting, or take a Follow-the-Leader approach [42] and go with the most probable model recommended by the most probable policy (i.e. use w t = ω maxind(q t ) (x t )).As shown in experimental results section and further discussed in Appendix (outperformance over the best policy/expert section), CAMS outperforms these policies in a wide range of practical applications. The model selection steps are detailed in Line 5-9 in Fig. 1.

Active queries. Under a limited budget, we intend to query the labels of those instances that exhibit significant disagreement among the pre-trained models F. To achieve this goal, we design an adaptive query strategy with query probability z t . Concretely, given context x t , model predictions ŷt and model distribution w t , we denote by εy t := ⇑w t , I {ŷ t ⇒ = y}⇓ as the expected loss if the true label is y. We characterize the model disagreement as

Intuitively, when εy t is close to 0 or 1, there is little disagreement among the models in labeling x t as y, otherwise there is significant disagreement. We capture this insight with function h(x) = ↑x log x. Since the label y t is unknown upfront when receiving x t , we iterate through all the possible labels y ↔ Y and take the average value as in Eq. (3). Note that E takes a similar algebraic form to the entropy function, although it does not inherit the information-theoretic interpretation.

With the model disagreement term defined above, we consider an adaptive query probabilityfoot_2

where ϱ t 0 = 1 ≃ t ↔ (0, 1] is an adaptive lower bound on the query probability to encourage exploration at an early stage. The query strategy is summarized in Line 10-14 in Fig. 1.

Model updates. Now define U t ⇔ Ber (z t ) as a binary query indicator that is sampled from a Bernoulli distribution parametrized by z t . Upon querying the label y t , one can calculate the loss for each model f j ↔ F as ε t,j = I {ŷ t,j ⇒ = y t }. Since CAMS does not query all the i.i.d. examples, we introduce an unbiased loss estimator for the models, defined as εt,j = εt,j zt U t . The unbiased loss of policy ω i ↔ " → can then be computed as εt,i = ⇑ω i (x t ), εt,j ⇓. In the end, CAMS computes the (unbiased) cumulative loss of policy ω i as LT,i = T t=1 εt,i , which is used to update the policy probability distribution in next round. Pseudocode for the model update steps is summarized in Line 15-21 in Fig. 1.

Remark. CAMS runs efficiently with time complexity O (nk) per round and space complexity O ((n + k) • k). At each round, each model selection policy specifies a probability distribution over the models for the given context. When these distributions correspond to constant Dirac delta distributions (regardless of the context), the problem reduces to the context-free problem investigated by Karimi et al. [39].

Stochastic setting

Under the stochastic setting, the cumulative loss of CAMS over T rounds-as specified by the RECOMMEND procedure-is L CAMS T = T t=1 εt,maxind(wt) where recall w t = i↘|! → | q t,i ω i (x t ) is the probability distribution over F induced by the weighted policy.

Let i → = arg min i↘[|! → |] µ i be the index of the best policy (µ i denotes the expected loss of policy i, as defined in problem statement section. The cumulative expected loss of policy i → is T µ i → ; therefore the expected pseudo-regret (Eq. ( 1)

Define ! := min i↔ =i → (µ i ↑ µ i → ) as the minimal sub-optimality gap 4 in terms of the expected loss against the best policy i → . Furthermore, let w t i → := ω i → (x t ) be probability distribution over F induced by policy i → at round t. We define ς := min xt {max wj ↘w t i → w j ↑ max wj ↘w t i → ,j↔ =maxind(w t i → ) w j } (5) as the minimal probability gap between the most probable model and the rest (assuming no ties) induced by the best policy i → . We further define b = p min log c (1/p min ), where p min = min s,i ω(x s ) denotes the minimal model selection probability by any policy 5 . As our first main theoretical result, we show that, without exhaustively querying the labels of the stochastic stream, CAMS achieves constant expected regret. Theorem 1. (Regret) In the stochastic environment, with probability at least 1 ↑ ϱ, CAMS achieves

Note that in the stochastic setting, a lower bound of # ((log " → ) /!) was shown in Mourtada and Gaïffas [50] for online learning problems with expert advice under the full information setting (i.e. assuming labels are given for all data points in the stochastic stream). To establish the proof of Theorem 1, we consider a novel procedure to connect the weighted policy by CAMS to the best policy ω i → . Conceptually, we would like to show that, after a constant number of rounds φ const , with high probability, the model selected by CAMS (Line 32) will be the same as the one selected by the best policy i → . In that way, the expected pseudo regret will be dominated by the maximal cumulative loss up to φ const . Toward this goal, we first bound the weight of the best policy w t,i → as a function of t, by choosing a proper learning rate ϑ t (CAMS, Line 23). Then, we identify a constant threshold φ const , beyond which CAMS exhibits the same behavior as ω i → with high probability. Finally, we obtain the regret bound by inspecting the regret at the two stages separately. The formal statement of Theorem 1 and the detailed proof are deferred to App. E.1.

Next, we provide an upper bound on the query complexity in the stochastic setting. Theorem 2. (Query Complexity). For c-class classification problems, with probability at least 1 ↑ ϱ, the expected number of queries made by CAMS over T rounds is upper bounded by

Theorem 2 is built upon Theorem 1, where the the key idea behind the proof is to relate the number of updates to the regret. When T µ i → , LT,→ are regarded as constants (given by an oracle), the query-complexity bound is then sub-linear w.r.t. T . Note that the number of class labels c affects the quality of the query complexity bound. The intuition behind this result is, with larger number of classes, each query may carry more information upon observation. For instance, in an extreme case where only one expert always recommends the best model and others gives random recommendations of models (and predicts random labels), having more classes lowers the chance of a model making the correct guess, and therefore helps to "filter out" those suboptimal experts in fewer rounds-hence being more query efficient. We defer the proof of Theorem 2 to App. E.2.

Adversarial setting

Now we consider the adversarial setting. Let LT,→ :

T t=1 εt,i be the cumulative loss of the best policy. The expected regret (Eq. ( 2)) for CAMS equals to R T (CAMS) = E T t=1 ⇑q t , ε ε ε t ⇓ ↑ LT,→ . We show that under the adversarial setting, CAMS achieves sub-linear regret in T without accessing all labels. Theorem 3. (Regret) Let c be the number of classes and ϖ t be specified as Line 26-27 in the SETRATE procedure. Under the adversarial setting, the expected regret of CAMS is bounded by

The proof is provided in App. F.1. Assuming ϖ t to be a constant, our regret upper bound in Theorem 3 matches (up to constants) the lower bound of #  T ln |" → | for online learning problems with expert advice under the full information setting [15,63] (i.e. assuming labels are given for all data points). Hereby, the decaying learning rate ϑ t as specified in Line 27 is based on two parameters, where 1/ ′ t corresponds to the lower bound ϱ t 0 on the query probability, and

) is a (data-dependent) term that is chosen to reduce the impact of the randomized query strategy on the regret bound (especially when t is large). Intuitively, ϖ t relates to the skewness of the policy where the max term corresponds to the maximal probability of most probable mispredicted label over t rounds. Note that in theory ϖ t can be small (e.g. CAMS may choose a constant policy ω const i ↔ " → that mispredict the label for x t , which leads to ϖ t = 0); in such cases, our result still translates to a sublinear regret bound of O(c

Furthermore, in practice, we consider to "regularize" the policies (App. D.4) to ensure that probability a policy selecting any model is bounded away from 0.

Finally, the following theorem (proof in App. F.2) establishes a query complexity bound of CAMS. Theorem 4. (Query Complexity). Under the adversarial setting, the expected query complexity over

Policy sets.

We construct the policy sets " for each dataset following a procedure similar to Meta-selector [48]. In this approach, a set of recommender algorithms is considered, and Meta-selector assigns varying ratings to these algorithms based on the specific user. Concretely, we first construct a set of models trained on different subsamples from each dataset. We then construct a set of policies, which include malicious, normal, random, and biased policy types for each dataset based on different models and features. Details on the classifiers and policies are provided in the supplemental materials. The malicious policy provides contrary advice; the random policy provides random advice; the biased policy provides biased advice by training on a biased distribution for classifying specific classes. The normal policy gives reasonable advice, being trained under a standard process on the training set. We represent the output of the i th policy as ω i (x t ), indicating the rewards distribution of all the base classifiers on x t . In total, we create 80, 10, 6, 4 classifiers and 85, 11, 17, 20 policies for CIFAR10, DRIFT, VERTEBRAL, and HIV, respectively.

Baselines. We evaluate CAMS against both contextual and non-contextual active model selection baselines. We consider four non-contextual baselines: (1) Random Query Strategy (RS) which queries the instance label with a fixed probability b T ;

(2) Model Picker (MP) [39] that employs variancebased active sampling with a coin-flip query probability max {v (ŷ t , w t ) , ϑ t }, where the variance term is defined as v (ŷ t , w t ) = max y↘Y εy

) Query by Committee (QBC) implementing committee-based sampling [22]; and (4) Importance Weighted Active Learning (IWAL) [8] that calculates query probability based on labeling disagreements of surviving classifiers. Since no contextual baselines exist yet, we propose contextual versions of QBC and IWAL as (5) CQBC and (6) CIWAL. Both extensions maintain their respective original query strategies but incorporate the context into the cumulative rewards. For model selection, CAMS, MP, CQBC, and CIWAL recommend the classifier with the highest probability. The other baselines use Follow-the-Leader (FTL), recommending the model with the minimum cumulative loss for past queried instances. Finally, we add (7) Oracle to represent the best single policy with the minimum cumulative loss, with the same query strategy as CAMS.

Ablation studies

Effectiveness of active querying. In Fig. 3a and Fig. 3b, we perform ablation studies to demonstrate the effectiveness of our active query strategy. We fix the model recommendation strategy as the one used by CAMS, and compare three query strategies: (1) CAMS, (2) the state-of-the-art variancebased query strategy from Model Picker [39] (referred to as "variance"), and (3) a random query strategy. Figure 3a demonstrates that CAMS has the fastest convergence rate in terms of cumulative loss on CIFAR10, implying effective use of queried labels. Furthermore, CAMS not only achieves the minimum cumulative loss but also incurs significantly lower query costs, with reductions of 71% and 95% compared to the variance and random strategies respectively as showed in Fig. 3b. This suggests that CAMS selectively queries data to optimize policy improvement, whereas the other strategies may query unnecessary labels, including potentially noisy or uninformative ones, which impede policy improvement and convergence.

Robustness. In Fig. 2, 3c, 3d,3e, 3f, and 3g, CAMS exhibits robustness in a variety of environmental settings. Firstly, As shown in Fig. 2, CAMS outshines other methods in a contextual environment, whereas in Fig. 3c, a non-contextual (no experts) environment, it achieves comparable performance to the state-of-the-art Model Picker in identifying the best classifier. Secondly, CAMS is robust in both stochastic and adversarial environments. As demonstrated in Fig. 2, CAMS surpasses other methods in a stochastic environment. Additionally, as illustrated in Fig. 3d, in a worst-case adversarial environment, CAMS effectively recovers from adversarial actions and approaches the performance of the best classifier (see App. G.5). We further observe that CAMS demonstrates robustness to varying scales of data, where the online stream sizes range from 80 to 10K (Fig. 2) to 100K (Fig. 3e, where we randomly sample 100K samples from the CovType dataset [24]).

In Fig. 2, we assume that the stream length T is hidden and not used as input to CAMS. Under the stochastic setting, however, knowing T can provide additional information that one can leverage to optimize the query probability, thereby giving an advantage to some of the baseline algorithms (e.g. random). As an ablation study, in Fig. 3f and Fig. 3g, we assume the stochastic setting where the total length T of the online stream is given. Given the stream length T and query budget b, we may optimize each algorithm by scaling their query probabilities, so that each algorithm allocates its query budget to the top b informative labels in the entire online stream based on its own query criterion. CAMS still ourperform the baselines under the setting.

Improvement over the best classifier and policy. Fig. 3h demonstrates that when provided with good policies, CAMS formulates a stronger policy which incurs no regret. CAMS has the potential to outperform an oracle, especially in rounds where the oracle does not make the optimal recommendation. For instance, in the stochastic version of CAMS (as shown in lines 22-23 and 30-32 of Fig. 1), CAMS recommends a model using a weighted majority vote among all policies, enabling the formation of a new policy in each round by amalgamating the strengths of each sub-optimal policy. This adaptive strategy can potentially outperform any single policy. Moreover, in most real-world scenarios and conducted experiments (as depicted in App. G.6), data streams may not be strictly stochastic, and therefore no single policy consistently performs the best. In such cases, CAMS's weighted policy may find an enhanced combination of "advices", leading to improved performance.

B Table of

Notations Defined in the Main Paper notation meaning Problem Statement X input domain x input instance, x ↔ X t, T index of a round, total number of rounds i, j index of policies, models/classifiers n number of policies k number of classifiers Y { 0, . . . , c ↑ 1}, set of c possible class labels for each input instance c number of class labels, |Y| !

model selection policy (expert) ω : X ↓ ! k↑1 , probability of selecting each classifier under input x ω const ω const j (•) := e j , e j ↔ ! k↑1 denotes the canonical basis vector with e j = 1 " collection of model selection policies

best policy ŷt,j f j (x t ), predicted label for j th pre-trained classifier at round t y t true label of x t ŷt [ŷ t,1 , . . . , ŷt,k ] ↓ , predicted labels by all k models at round t ε t,j I {ŷt,j ↔ =yt} , 0-1 loss for model j ↔ [k] at round t ε ε ε t I {ŷ t ↔ =yt} , full loss vector upon observing y t A the learner L A T T t=1 ε t,jt , cumulative loss over T rounds for a learning algorithm A εt,i ⇑ω i (x t ) , ε ε ε t ⇓, expected loss if the learner commits to policy ω i and take random selection at round t maxind(w) arg max j,wj ↘w w j , index of maximal value entry of w µ 1 T T t=1 E xt,yt εt,maxind(ωi(xt)) R T (A), R T (A) expected regret in adversarial setting, pseudo-regret for stochastic setting E t [•] E[•|F t ], F t = ↼ E (1) , ŷ1 , ..., ŷt↑1 , E (t) Algorithm q t (q t,i ) i↘|! → | , probability distribution over " → at t Lt,i t ϖ =1 εϖ,i , cumulative loss of policy i w t i↘|! → | q t,i ω i (x t ), distribution induced by the weighted policy εy t ⇑w t , I {ŷ t ⇒ = y}⇓, expected loss if the true label is y E (ŷ t , w t ) model disagreement function h(x) ↑x log x ϱ t 0 1 ≃ t , lower bound of query probability z t max {ϱ t 0 , E (ŷ t , w t )}, adaptive query probability εt,j εt,j zt U t U query indicator ϑ t adaptive learning rate ϖ

unbiased estimate of classifier loss vector

unbiased estimate of policy loss vector  L unbiased cumulative loss of classifiers, policies Analysis p t,y j↘[k] I {ŷ t,j = y} w j , the total probability of classifiers predicts label y at round t

sub-optimality gap or immediate regret of policy i L T,→ the cumulative loss of oracle at round T

Table 3: Regret and query complexity bounds. For the notations in this table: i → is the model with the highest expected accuracy; ⇀ j

is the probability that exactly one of j and i → correctly classifies a sample; ς and ϖ T are defined in Eq. ( 5) and ( 6), respectively. b = p min log c (1/p min ), where p min = min s,i ω(x s ) denotes the minimal model selection probability by any policy.

Remark 5. When T µ i → , LT,→ are regarded as constants (given by an oracle), the query-complexity bound is then sub-linear w.r.t. T .

Remark 6. Note that the number of class labels c affects the quality of the query complexity bound. The intuition behind this result is, with larger number of classes, each query may carry more information upon observation. For instance, in an extreme case where only one expert always recommends the best model and others gives random recommendations of models (and predicts random labels), having more classes lowers the chance of a model making the correct guess, and therefore helps to "filter out" those suboptimal experts in fewer rounds-hence being more query efficient.

Remark 7. To prove the practical feasibility of CAMS, we have analyzed its time and space complexity.

Our analysis shows that CAMS has a time complexity of O (T nk) in total or O(nk) per round (due to the RECOMMEND procedure under the stochastic setting), and a space complexity of O ((n + k) • k).

Here, T refers to the online horizon, n denotes the number of policies, and k denotes the number of models. Taking into account these complexities, we can confirm that CAMS is practically feasible.

D Supplemental Materials on Experimental Setup D.1 Baselines

Model Picker (MP) Model Picker [39] is a context-free online active model selection method inspired by EXP3. Model Picker aims to find the best classifier in hindsight while making a small number of queries. For query strategy, it uses a variance-based active learning sampling method to select the most informative label to query to differentiate a pool of models, where the variance is defined as

. The coin-flip query probability is defined as max {v (ŷ t , w t ) , ϑ t } when v (ŷ t , w t ) ⇒ = 0, or 0 otherwise. For model recommendation, it uses an exponential weight algorithm to recommend the model with minimal exponential cumulative loss based on the past queried labels at each round.

Query by Committee (QBC) For query strategy, we have adapted the method of [22] as a disagreement-based selective sampling query strategy for online streaming data. We treat each classifier as a committee member and compute the query probability by measuring disagreement between models for each instance. The query function is coin-flip by vote entropy probability

, where V (c, x) stands for the number of committee members assigning a class c for input context x and k is the number of committee. For the model recommendation part, we use the method of Follow-the-Leader (FTL) [42], which greedily recommends the model with the minimum cumulative loss for past queried instances.

Importance Weighted Active Learning (IWAL) We have implemented [8] as the IWAL baseline. For the query strategy part, IWAL computes an adaptive rejection threshold for each instance and assigns an importance weight to each classifier in the hypothesis space H t . IWAL retains the classifiers in the hypothesis space according to their weighted error versus the current best classifier's weighted error at round t. The query probability is calculated based on labeling disagreements of surviving classifiers through function max i,j↘Ht,y↘[c] ε (y) t,i ↑ ε (y) t,j . For model recommendation, we also adopt the Follow-the-Leader (FTL) strategy.

Random Query Strategy (RS) The RS method queries the label of incoming instances by the coin-flip fixed probability b T . It also uses the FTL strategy based on queried instances for model recommendation.

Contextual Query by Committee (CQBC) We have created a contextual variant of QBC termed CQBC, which has the same entropy query strategy as the original QBC. For model recommendation, we combine two model selection strategies. The first strategy calculates the cumulative reward of each classifier based on past queries and normalizes it as a probability simplex vector. We also adopt Exp4's arm recommending vector to use contextual information. Finally, we compute the element-wise product of the two vectors and normalize it to be CQBC's model recommendation vector. At each round, CQBC would recommend the top model based on the classifiers' historical performance on queried instances and the online advice matrix for streaming data.

VERTEBRAL:

We have built six classifiers using Random Forest [10], Gaussian Process [56], linear discriminant analysis [26], Naive Bayes [31] algorithms. We have constructed policies by using standard scikit-learn built-in models including Random Forest Classifier, Extra Trees Classifier [30], Decision Tree Classifier, Radius Neighbors Classifier [51], Ridge Classifier [57] and K-Nearest-Neighbor classifiers. 6 To list a few other scenarios beyond the ones used in the paper: In healthcare, models could be the treatments, experts could be the doctors and the context could be the condition of a patient. For any patient (context), doctors (experts) will have their own advice on the treatment (model) recommendation for this patient based on their past experience. In the finance domain, models could be trading strategies, experts could be portfolio managers, and the context could be the stock/equity. Some trading strategies (models) might work well for the information technology sector, and some other models might work well for the energy sector, so depending on the sector of stock (context), different portfolio managers (experts) might have their own advice on different trading strategies (models) based their past trading experience.

HIV: We have used graph convolutional networks (GCN) [40], Graph Attention Networks (GAT) [72], AttentiveFP [75], and Random Forest to construct 4 classifiers. We have also used various feature representations of molecules such as MACCS key [25], ECFP2, ECFP4, and ECFP6 [58] molecular fingerprints to build 6 MLP-based policies, respectively.

CovType: We have built 6 classifiers using Random Forest, Gaussian Process, linear discriminant analysis, Naive Bayes algorithms. We have constructed 17 policies by using standard scikit-learn built-in models including Random Forest Classifier, Extra Trees Classifier, Decision Tree Classifier, Radius Neighbors Classifier, Ridge Classifier and K-Nearest-Neighbor classifiers.

E.1 Proof of Theorem 1

Before providing the proof of Theorem 1, we first introduce the following lemma. Lemma 8. Fix φ ↔ (0, 1). Let q t,i → be the probability of the optimal policy i → maintained by Algorithm 1 at t, and let b = p min log c (1/p min ), where p min = min s,i ω(x s ) denotes the minimal model selection probability by any policy 7. When t ↗   ln

, with probability at least 1 ↑ ϱ, it holds that q t,i → ↗ φ .

Proof of Lemma 8. W.l.o.g, we assume

, and ω 1 is the policy with the minimal expected loss.

Define

where i ⇐ ↫ arg min i↔ =1 Lt↑1,i denotes the index of the best empirical policy up to t ↑ 1 other than ω 1 . Therefore for i ↗ 2, it holds that

We have q t,i → = q t,1 = exp(↑ςt Lt↑1,1)

as the weight of optimal expert at round t. Therefore

where step (a) is by dividing the cumulative loss of sub-optimal policy ω i ↓ and step (b) is by the definition of ϱ t in Equation (7).

Let φ ↔ (0, 1), such that q t,i → ↗ exp(ςt t s=1 ϱs) exp(ςt

. Rearranging the terms, we get

Next, we seek a high probability upper bound on ϱ t . Denote

We know

Here, step (9a) is by the fact that ! 2 = min i↔ =1 ! i ≃ ! i ↓ , and step (9b) is by Hoeffding's inequality where b denotes the upper bound on |ϱ s |. Further note that

≃ U s ⇑ω i ↓ (x s ), I {ŷ s ⇒ = y s }⇓

, it holds that q t,i → ↗ φ with probability at least 1 ↑ ϱ.

Lemma 9. At round t, when t ↗

, it holds that the arm chosen by the best policy i → will be the arm chosen by Algorithm 1 with probability at least 1 ↑ ϱ. That is, arg max

Proof of Lemma 9. At round t, for Algorithm 1, we have loss

as the minimal gap in model distribution space of best policy. The arm recommended by the best policy i → of CAMS will dominate CAMS's selection, when we have

Rearranging the terms, and by

Therefore, we get φ • (ς) ↗ (1 ↑ φ ), and thus φ ↗ 1 ↼+1 . Set φ ↗ 1 ↼+1 . By Lemma 8, we get

where the last step is by applying 2e ↑ tϖ 2 2b 2 = ϱ, thus, ⇁ = 2bfoot_6 t ln 2 ϱ . Dividing both sides by t

Proof of Theorem 1. Therefore, with probability at least 1 ↑ ϱ , we get constant regret

Furthermore, with probability at most ϱ, the regret is upper bounded by T . Thus, we have

where step (a) by setting ϱ = 1 T , and where ς in Eq. ( 10) is the min gap.

E.2 Proof of Theorem 2

In this section, we analyze the query complexity of CAMS in the stochastic setting, where we take a similar approach as proposed by Karimi et al. [39] for the context-free model selection problem. Our main idea is to derive from query indicator U t and query probability z t . We first used Lemma 10 to bound the expected number of queries T t=1 U t by the sum of query probability as

Then we used Lemma 11 to bound the first item (which corresponds to the lower bound of query probability over T rounds) and applied Lemma 12 to bound the second term (which characterizes the model disagreement). Finally, we combined the upper bounds on the two parts to reach desired result.

Lemma 10. The query complexity of Algorithm 1 is upper bounded by

Proof. Now we have model disagreement defined in Eq. ( 3), the query probability defined in Eq. ( 4), and the query indicator U. Let us assume, at each round, we have query probability z t > 0, which indicates we will not process the instance that all the models' prediction are the same.

At round t, from query probability Eq. ( 4), we have

, where the inequality is by applying that ∝A, B ↗ 0, max{A, B} ≃ A + B.

Thus, in total round T , we could get the following equation as the cumulative query cost,

where the inequality is by inputting ϱ t 0 = 1 ≃ t and Eq. ( 3).

Lemma 11.

T t=1

Proof. We can bound the LHS as follows:

Lemma 12. Denote the true label at round t by y t , and define p t,y := j↘[k] I {ŷ t,j = y} w j . Further define R t := t 1 ↑ p t,yt as the expected cumulative loss of Algorithm 1 at t.

Proof of Lemma 12. Suppose at round t, the true label is y t .

yt ) log |Y| 1 1↑pt,y t |Y| + y↔ =yt (1 ↑ p t,y ) log |Y| 1 1↑pt,y |Y| (a) ≃ (1 ↑ p t,yt ) log |Y| 1 1↑pt,y t |Y| + ↑ 1) (1↑pt,y t ) |Y|↑1 log |Y| |Y|↑1 1↑pt,y t |Y| ≃ (1 ↑ p t,yt ) log |Y| 1 1↑pt,y t |Y| + (1 ↑ p t,yt ) log |Y| |Y|↑1 1↑pt,y t |Y| = (1 ↑ p t,yt ) log |Y| |Y|↑1 (1↑pt,y t ) 2 |Y| (b) ≃ r t log |Y| |Y|↑1 r 2 t |Y| , where step (a) is by applying Jensen's inequality and using 1 ↑ p t,y = 1↑pt,y t |Y|↑1 , and step (b) is by replacing the expected loss 1 ↑ p t,yt by its short-hand notation r t .

Recall that we define the expected cumulative loss as

Since R T is the cumulative loss up to round T , T 's incremental rate is no less than R T 's incremental rate. Thus, R T ≃ T and Tt Rt ≃ Tt+1 Rt+1 . So we get Eq. ( 14). Now we are ready to prove Theorem 2.

Proof of Theorem 2. From Lemma 10, we get the following equation as the cumulative query cost

Let us assume the expected total loss of best policy is T µ i → . From Theorem 1, we get

Plugging this result into the query complexity bound given by Lemma 11 and Lemma 12, we have

, where ς is defined as Eq. ( 10) and step (a) by applying c = |Y|.

F.1 Proof of Theorem 3

Lemma 13. Consider the setting of Algorithm 1, Let us define h t,i = exp ↑ϑ t Lt↑1,i ∝i ↔ |" → | as exponential cumulative loss of policy i, ϑ t is the adaptive learning rate and q t is the probability distribution of policies, then

Proof. We first bound the following term

where the inequality is by applying that for x ≃ 0, we have

By taking log on both side, we get

where step (a) is by applying that log (1 + x) ≃ x, when x ↗ ↑1.

Now summing over t = 1 : T yields:

Lemma 14. Consider the setting of Algorithm 1. Let p t,y = j↘[k] I {ŷ t,j = y} w j . The query probability z t satisfies

Proof. We first bound the query probability term

yt (1 ↑ p t,yt ) + p t,y (1 ↑ p t,y )) , ∝y ⇒ = y t , where step (a) is by applying ln (1 + x) ↗ x 1+x for x > ↑1, ln 1 1 ↑ p t,y = ln 1 + p t,y 1 ↑ p t,y ↗ pt,y 1↑pt,y 1 1↑pt,y = p t,y , and where step (b) is by applying ∝a, b ↔ R, max {a, b} ↗ a. Proof of Theorem 3. By applying Lemma 13, we got

For any policy s, we have a lower bound

where step (a) in Eq. ( 15) is by initializing  L 0 = 0, e 0 = 1, and

Thus, we have

≃ log (n + k)

where step (b) is by applying

and step (c) is by dividing ϑ T on both side.

Because we have

where step (d) is by applying

, where step (e) is by using ⇑w t , ε ε ε t ⇓ = 1 ↑ p t,yt and step (f ) by using Lemma 14 and get lower bound of z t as 1 |Y| ln |Y| (p t,yt (1 ↑ p t,yt ) + p t,y (1 ↑ p t,y )) and applying

p ϖ,y . Let p t,ŷ = max y p t,y . Thus, we have

So we have

where step (g) is by getting the lower bound of z t as

where the last inequality is due to the fact that

which completes the proof.

G.5 Robustness against malicious experts in adversarial environments

When given only malicious and random advice policies, the conventional contextual online learning from experts advice framework will be trapped in the malicious or random advice. In contrast, CAMS could efficiently identify these policies and avoid taking advice from them. Meanwhile, it also successfully identifies the best classifier to learn to reach its best performance.

Cumulative loss (a) CIFAR10 (b) DRIFT (c) VERTEBRAL (d) HIV Cumulative loss (a) CIFAR10 (b) DRIFT (c) VERTEBRAL (d) HIV Figure 7: Comparing the model selection strategy of CAMS and Model Picker baseline based on the same variance-based query strategy in a context-free environment. CAMS has approximately the same performance as Model Picker on all the benchmarks. 90% confident intervals are indicated in shades.

The novelty in CAMS that enables this robustness is that we add the constant policies {ω const 1 , . . . , ω const k } into the policy set " to form the new set as " → . To illustrate the performance difference, we have created a variant of CAMS by adapting to the conventional approach (named CAMS-conventional). Fig. 8 demonstrates that CAMS could outperform all the malicious and random policies and converge to the performance of the best classifier. CAMS-conventional: We create the CAMS-conventional algorithm as the CAMS using policy set ", not " → . Figure 8: Evaluating the robustness of CAMS compared to the conventional learning from experts' advice (CAMS-conventional) in a complete malicious and random policies environment. When no good policy is available, CAMS could recover from malicious advice and successfully approach the performance of the best classifier. In contrast, the conventional approach will be trapped in malicious advice. 90% confident intervals are indicated in shades.

G.6 Outperformance over the best policy/expert

We also observe that CAMS does not stop at approaching the best policy or classifier performance. Sometimes, it even outperforms all the policies and classifiers, and Fig. 9 demonstrates such a case.

To demonstrate the advantage of CAMS, we create two variant versions of CAMS: (1) CAMS-MAX (App. G.7), (2) CAMS-Random-Policy (App. G.8). CAMS-MAX and CAMS-Random-Policy use the same algorithm as CAMS in adversarial settings but have different model selection strategies for ablation study in the stochastic settings.

We evaluate the three algorithms on VERTEBRAL and HIV benchmarks in terms of (a) normal policies (Fig. 9 Left), (b) classifiers (Fig. 9 Middle), and (c) malicious and random policies (Fig. 9 Right). In the normal policies column, we only compare the policies with regular policies giving helpful advice. In the classifier column, we compare them with the performance of classifiers only.

In the malicious and random policies column, we compare them with unreasonable policies only.

Fig. 9 demonstrates that all three algorithms could outperform the malicious/random policies. However, CAMS-Random-Policy does not outperform the best classifier while both CAMS and CAMS-MAX can on both benchmarks. CAMS-MAX approaches the performance of the best policy but does not outperform the best policy on both benchmarks. Finally, perhaps surprisingly, CAMS outperforms the best policy (Oracle) on both benchmarks and continues to approach the hypothetical, optimal policy (with 0 cumulative loss).

This surprising factor is contributed by the adaptive weighted policy of CAMS, which adaptively creates a better policy by combining the advantage of each sub-optimal policy and classifier to reach the performance of the hypothetical, optimal policy (defined as

The second reason could be that the benchmark we created, or any real-world cases, will not be strictly in a stochastic setting (in which a single policy outperforms all others or has lower µ in every round). The weight policy strategy can make a better combination of advice for this case. They outperform all the malicious/random policies. Moreover, CAMS and CAMS-MAX outperform the best classifier. Finally, only CAMS even exceeds the best policy (Oracle) in both benchmarks and continues approaching the hypothetical, optimal policy (0 cumulative loss). 90% confident intervals are indicated in shades.

G.11 Fine-tuning the query probabilities for stochastic streams

For the experimental results we reported in the main paper, we consider a streaming setting where the data arrives online in an arbitrary order and arbitrary length. Therefore, for both CAMS and the baselines, we used the exact off-the-shelf query criteria as described in experiment setup section without fine-tuning the query probabilities, which could be otherwise desirable in certain scenarios (e.g. for stochastic streams, where the query probability can be further optimized).

In this section, we consider such scenarios, and conduct an additional set of experiments to further demonstrate the performance of CAMS assuming stochastic data streams. Given the stream length T and query budget b, we may optimize each algorithm by scaling their query probabilities, so that each algorithm allocates its query budget to the top b informative labels in the entire online stream based on its own query criterion. Note that in practice, finding the exact scaling parameter is infeasible, as we do not know the online performance unless we observe the entire data stream. While it is challenging to determine the scaling factor for each algorithm under the adversarial setting, one can effectively estimate the scaling factor for stochastic streams, where the context arrives i.i.d..

Concretely, we use the early budget to decide the scaling parameter in our following evaluation: Firstly, we use a small fraction (i.e. T /10) of the online stream and see how much queries b early each algorithm consumed. Then we calculate the scaling parameter s = (b↑bearly)

T ↑T /10 • T /10 bearly and multiply the scaling factor with the query probability of each algorithm for the remaining 9 10 • T rounds. The results in Fig. 13 demonstrate that CAMS still outperforms all the baselines (excluding Oracle) when all algorithms select the top b data of the whole online stream to query. The improvement of CAMS over the baseline approaches does not differ much between the two versions (with or without scaling) of the experiments as shown in the bottom plots of Fig. 2 and Fig. 13.

For a head-to-head comparison between the bottom plots of Fig. 2 and Fig. 13, note that the total number of rounds stays the same for DRIFT (T = 3000), VERTEBRAL (T = 80), and HIV (T = 4000); while we used half the rounds and half the maximal budget for CIFAR10 (T = 5000) for the version with scaling. Roughly speaking, the cumulative regret plots for the baselines were "streched out" to cover the full allocated budget after scaling, but we do not observe a significant difference in terms of the absolute gain in terms of the cumulative loss. Another way to read the difference between the two plots is to compare the cumulative losses at the budget range where all algorithms were not cut off early: e.g., for DRIFT, when Query Cost is 250, the cumulative losses for the competing algorithm stay roughly the same under the two evaluation scenarios. G.12 Ablation study on the active query strategy

In this section, we compare the performance of CAMS and its non-active variant (CAMS-nonactive), which queries the label for each incoming data point. As shown in Fig. 14, CAMS performs equally well or better than CAMS-nonactive, even though it queries significantly less data. Surprisingly, on the DRIFT dataset, CAMS significantly outperforms CAMS-nonactive, even when using less than 10 percent of the query budget (Fig. 14b). This demonstrates that CAMS selectively choose the data to query to maximal optimize policy improvement, while CAMS queries all data points, regardless of their usefulness or noise, which hampers policy improvement and convergence.

G.13 Relative Cumulative Loss

Relative cumulative loss (RCL). At round t, we define RCL as L t,ji ↑ L t,j → , where L t,j → stands for the cumulative loss (CL) of the policy always selecting the best classifier, and L t,ji stands for the CL of policy i.

Relative cumulative loss The RCL under the same query cost for all baselines is shown in Fig. 15. The loss trajectory demonstrates that CAMS efficiently adapts to the best policy after only a few rounds and outperforms all baselines in all benchmarks. The result also demonstrates that CAMS can achieve negative RCL on all benchmarks, which means it outperforms any algorithms that chase the best classifier, as the horizontal 0 line represents the performance benchmark of best classifier. This empirical result aligns with Theorem 1 that, in the worst scenario, if the best classifier is the best policy, CAMS will achieve its performance. Otherwise, CAMS will reach a better policy and incurs no regret.

CAMS could achieve such performance because when an Oracle fails to achieve 0 loss over all instances and contexts, CAMS has the opportunity to outperform the Oracle in those rounds Oracle does not make the best recommendation. For instance, the stochastic version of CAMS (Line 22-23; Line 30-32 in Fig. 1) may achieve this by recommending a model using the weighted majority vote among all policies. Therefore, one can view CAMS as adaptively constructing a new policy at each round by combining the advantages of each sub-optimal policy, which may outperform any single expert/policy. Furthermore, for the experiments we ran (or in most real-world scenarios), the data streams are not strictly in a stochastic setting (in which a single policy outperforms all others or has a lower expected loss in every round). The weighted policy strategy may find a better combination of "advices" in such cases (see Fig. 2 and App. G.6).

Limitations

Question: Does the paper discuss the limitations of the work performed by the authors?

Answer: [Yes]

Justification: We have discussed our limitation at Section 7 future direction. It summarizes the limitations of our approach and we hope to address in the future work.

Guidelines:

• The answer NA means that the paper has no limitation while the answer No means that the paper has limitations, but those are not discussed in the paper. • The authors are encouraged to create a separate "Limitations" section in their paper.

• The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g., independence assumptions, noiseless settings, model well-specification, asymptotic approximations only holding locally). The authors should reflect on how these assumptions might be violated in practice and what the implications would be. • The authors should reflect on the scope of the claims made, e.g., if the approach was only tested on a few datasets or with a few runs. In general, empirical results often depend on implicit assumptions, which should be articulated. • The authors should reflect on the factors that influence the performance of the approach.

For example, a facial recognition algorithm may perform poorly when image resolution is low or images are taken in low lighting. Or a speech-to-text system might not be used reliably to provide closed captions for online lectures because it fails to handle technical jargon. • The authors should discuss the computational efficiency of the proposed algorithms and how they scale with dataset size. • If applicable, the authors should discuss possible limitations of their approach to address problems of privacy and fairness. • While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, a worse outcome might be that reviewers discover limitations that aren't acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an important role in developing norms that preserve the integrity of the community. Reviewers will be specifically instructed to not penalize honesty concerning limitations.

Theory Assumptions and Proofs

Question: For each theoretical result, does the paper provide the full set of assumptions and a complete (and correct) proof?

• The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, or overall run with given experimental conditions). • The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap, etc.) • The assumptions made should be given (e.g., Normally distributed errors). • It should be clear whether the error bar is the standard deviation or the standard error of the mean.

• It is OK to report 1-sigma error bars, but one should state it. The authors should preferably report a 2-sigma error bar than state that they have a 96% CI, if the hypothesis of Normality of errors is not verified. • For asymmetric distributions, the authors should be careful not to show in tables or figures symmetric error bars that would yield results that are out of range (e.g. negative error rates). • If error bars are reported in tables or plots, The authors should explain in the text how they were calculated and reference the corresponding figures or tables in the text. 8. Experiments Compute Resources Question: For each experiment, does the paper provide sufficient information on the computer resources (type of compute workers, memory, time of execution) needed to reproduce the experiments? Answer: [Yes] Justification: It can be found at the supplementary Appendix D.6. Guidelines: • The answer NA means that the paper does not include experiments. • The paper should indicate the type of compute workers CPU or GPU, internal cluster, or cloud provider, including relevant memory and storage. • The paper should provide the amount of compute required for each of the individual experimental runs as well as estimate the total compute. • The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary or failed experiments that didn't make it into the paper). 9. Code Of Ethics Question: Does the research conducted in the paper conform, in every respect, with the NeurIPS Code of Ethics https://neurips.cc/public/EthicsGuidelines? Answer: [Yes] Justification: The codes are anonymous as well. Guidelines: • The answer NA means that the authors have not reviewed the NeurIPS Code of Ethics. • If the authors answer No, they should explain the special circumstances that require a deviation from the Code of Ethics. • The authors should make sure to preserve anonymity (e.g., if there is a special consideration due to laws or regulations in their jurisdiction). 10. Broader Impacts Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed? Answer: [Yes] Justification: It has been discussed at Abstract and Section 1.

Guidelines:

• The answer NA means that there is no societal impact of the work performed.

• If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact.

• Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations. • The conference expects that many papers will be foundational research and not tied to particular applications, let alone deployments. However, if there is a direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster. • The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology. • If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms to monitor how a system learns from feedback over time, improving the efficiency and accessibility of ML).

Safeguards

Question: Does the paper describe safeguards that have been put in place for responsible release of data or models that have a high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)? Answer: [NA] Justification: Guidelines:

• The answer NA means that the paper poses no such risks.

• Released models that have a high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere to usage guidelines or restrictions to access the model or implementing safety filters. • Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images. • We recognize that providing effective safeguards is challenging, and many papers do not require this, but we encourage authors to take this into account and make a best faith effort. 12. Licenses for existing assets Question: Are the creators or original owners of assets (e.g., code, data, models), used in the paper, properly credited and are the license and terms of use explicitly mentioned and properly respected? Answer: [NA] Justification: Guidelines:

• The answer NA means that the paper does not use existing assets.

• The authors should cite the original paper that produced the code package or dataset.

• The authors should state which version of the asset is used and, if possible, include a URL. • The name of the license (e.g., CC-BY 4.0) should be included for each asset.

• For scraped data from a particular source (e.g., website), the copyright and terms of service of that source should be provided. • If assets are released, the license, copyright information, and terms of use in the package should be provided. For popular datasets, paperswithcode.com/datasets has curated licenses for some datasets. Their licensing guide can help determine the license of a dataset.