Upload folder using huggingface_hub

3dSZUYjPwN/3dSZUYjPwN.md

@@ -0,0 +1,780 @@
+# Low-Regret Active Learning
+
+Anonymous authors Paper under double-blind review
+
+## Abstract
+
+We develop an online learning algorithm for identifying unlabeled data points that are most informative for training (i.e., active learning). By formulating the active learning problem as the prediction with sleeping experts problem, we provide a regret minimization framework for identifying relevant data with respect to any given definition of informativeness. Motivated by the successes of ensembles in active learning, we define regret with respect to an omnipotent algorithm that has access to an infinity large ensemble. At the core of our work is an efficient algorithm for sleeping experts that is tailored to achieve low regret on easy instances while remaining resilient to adversarial ones. Low regret implies that we can be provably competitive with an ensemble method *without the computational burden of having to train* an ensemble. This stands in contrast to state-of-the-art active learning methods that are overwhelmingly based on greedy selection, and hence cannot ensure good performance across problem instances with high amounts of noise. We present empirical results demonstrating that our method (i) instantiated with an informativeness measure consistently outperforms its greedy counterpart and (ii) reliably outperforms uniform sampling on real-world scenarios.
+
+## 1 Introduction
+
+Modern neural networks have been highly successful in a wide variety of applications ranging from Computer Vision (Feng et al., 2019) to Natural Language Processing (Brown et al., 2020). However, these successes have come on the back of training large models on massive labeled data sets, which may be costly or even infeasible to obtain in other applications. For instance, applying deep networks to the task of cancer detection requires medical images that can only be labeled with the expertise of healthcare professionals, and a single accurate annotation may come at the cost of a biopsy on a patient (Shen et al., 2019).
+
+Active learning focuses on alleviating the high label-cost of learning by only querying the labels of points that are deemed to be the most informative. The notion of informativeness is not concrete and may be defined in a task-specific way. Unsurprisingly, prior work in active learning has primarily focused on devising proxy metrics to appropriately quantify the informativeness of each data point in a tractable way. Examples include proxies based on model uncertainty (Gal et al., 2017), clustering (Sener & Savarese, 2017; Ash et al., 2019),
+and margin proximity (Ducoffe & Precioso, 2018) (see (Ren et al., 2020) for a detailed survey).
+
+An overwhelming majority of existing methods are based on greedy selection of the points that are ranked as most informative with respect to the proxy criterion. Despite the intuitiveness of this approach, it is known to be highly sensitive to outliers and to training noise, and observed to perform significantly worse than uniform sampling on certain tasks (Ebrahimi et al., 2020) - as Fig. 1 also depicts. In fact, this shortcoming manifests itself even on reportedly redundant data sets, such as MNIST, where existing approaches can lead to models with up to 15% (absolute terms) higher test error (Muthakana, 2019) than those obtained with uniform sampling. In sum, the general lack of robustness and reliability of prior (greedy) approaches impedes their widespread applicability to high-impact deep learning tasks. In this paper, we propose a low-regret active learning framework and develop an algorithm that can be applied with any user-specified notion of informativeness. Our approach deviates from the standard greedy paradigm and instead formulates the active learning problem as that of learning with expert advice in an adversarial environment. Motivated by the widespread success of ensemble approaches in active learning (Beluch et al.,
+
+![1_image_0.png](1_image_0.png)
+
+![1_image_1.png](1_image_1.png)
+
+Figure 1: Evaluations on FashionMNIST and ImageNet with benchmark active learning algorithms. Existing approaches based on greedy selection are not robust and may perform significantly worse than uniform sampling.
+2018), we define regret with respect to an oracle approach that has access to an infinitely large model ensemble.
+
+This oracle represents an omniscient algorithm that can completely smoothen out all training noise and compute the expected informativeness of data points over the randomness in the training. *Low regret in this* context (roughly) implies that we are robust to training noise and provably competitive with the performance of an ensemble, without the computational burden of having to train an ensemble of models.
+
+Overall, our work aims to advance the development of efficient and robust active learning strategies that can be widely applied to modern deep learning tasks. In particular, we:
+1. Formulate active learning as a prediction with sleeping experts problem and develop an efficient, predictive algorithm for low-regret active learning, 2. Establish an upper bound on the expected regret of our algorithm that scales with the difficulty of the problem instance, 3. Compare and demonstrate the effectiveness of the presented method on a diverse set of benchmarks, and present its uniformly superior performance over competitors across varying scenarios.
+
+## 2 Background & Problem Formulation
+
+We consider the setting where we are given a set of n unlabeled data points *P ⊂ X* n from the input space X ⊂ R
+d. We assume that there is an oracle Oracle that maps each point x ∈ P to one of k categories.
+
+Given a network architecture and sampling budget b ∈ N+, our goal is to generate a subset of points *S ⊂ P*
+with |S| = b such that training on {(x, Oracle(x))x∈S } leads to the most accurate model θ among all other choices for a subset *S ⊂ P* of size b.
+
+The iterative variant of acquisition procedure is shown as Alg. 1, where Acquire is an active learning algorithm that identifies (by using θt−1) bt unlabeled points to label at each iteration t ∈ [T] and Train trains a model initialized with θt−1 using the labeled set of points. We emphasize that prior work has overwhelmingly used the Scratch option (Line 6, Alg. 1), which entails discarding the model information θt−1 from the previous iteration and training a randomly initialized model from scratch on the set of labeled points acquired thus far, S.
+
+Active Learning Consider an informativeness function g : X ×Θ → [0, 1] that quantifies the informativeness of each point x ∈ X with respect to the model θ ∈ Θ, where Θ is the set of all possible parameters for the given architecture. An example of the gain function is the maximum variation ratio (also called the uncertainty metric) defined as g(*x, θ*) = 1 − maxi∈[k] fθ(x)i, where fθ(x) ∈ R
+kis the softmax output of the model θ given input x. As examples, the gain g(*x, θ*) of point x is 0 if the network is absolutely certain about the label of x and 1 − 1/k when the network's prediction is uniform. In the context of Alg. 1, prior work on active learning (Muthakana, 2019; Geifman & El-Yaniv, 2017; Gal et al., 2017; Sener & Savarese, 2017) has
+
+## Algorithm 1 Activelearning
+
+Input: Set of points P ⊆ R
+d×n, Acquire: an active learning algorithm for selecting labeled points 1: *S ← ∅*; θ0 ← Randomly initialized network model; 2: for t ∈ [T] = {1*, . . . , T*} do 3: St ← Acquire(P \ S, bt, θt−1) {Get new batch of bt ∈ N+ points to label using algorithm Acquire}
+4: *S ← S ∪ S*t {Add new points}
+5: (if Scratch option) θt−1 ← Randomly initialized network 6: θt ← Train(θt−1, {(x, Oracle(x))x∈S }) {Train network on the labeled samples thus far}
+7: **end for**
+8: **return** θT
+generally focused on greedy acquisition strategies (Acquire in Alg. 1) that rank the remaining unlabeled points by their informativeness g(x, θt−1) *as a function of the model* θt−1, and pick the top bt points to label.
+
+## 2.1 Greedy'S Shortcoming & Ensembles
+
+As observed in prior work (Ebrahimi et al., 2020; Muthakana, 2019) and seen in our evaluations, e.g.,
+Fig. 1, greedy approaches may perform significantly worse than naive uniform sampling. To understand why this could be happening, note that at iteration t ∈ [T] the greedy approach makes a judgment about the informativeness of each point using only the model θt−1 (Line 4 of Alg. 1). However, in the deep learning setting where stochastic elements such as random initialization, stochastic optimization, (randomized) data augmentation, and dropout are commonly present, θt−1 is itself a random variable with non-negligible variance.
+
+This means that, for example, we could get unlucky with our training and obtain a deceptive model θt−1
+(e.g., training diverged) that assigns high gains (informativeness) to points that may not truly be helpful towards training a better model. Nevertheless, Greedy would still base the entirety of the decision making solely on θt−1 and blindly pick the top-bt points ranked using θt−1, leading to a misguided selection. This also applies to greedy clustering, e.g., Coreset (Sener & Savarese, 2017), Badge (Ash et al., 2019). Relative to Greedy, the advantage of ensemble methods is that they are able to smoothen out the training noise and select points with *high expected informativeness* over the randomness in the training. In other words, rather than greedily choosing the points with high informativeness g(*x, θ*t−1) with respect to a single model, ensembles can be viewed as selecting points with respect to a finite-sample approximation of E θt−1
+[g(*x, θ*t−1)]
+by considering the informativeness over multiple trained models.
+
+## 2.2 Active Learning As Prediction With Expert Advice
+
+Roughly, we consider our active learning objective to be the selection of points with maximum *expected* informativeness E θt−1
+[g(*x, θ*t−1)] over the course of T active learning iterations. By doing so, we aim to smoothen out the training noise in evaluating the informativeness as ensembles do, but *in an efficient way by* training only a single model at a time as in Alg. 1. For sake of simplicity, we present the problem formulation for the case of sampling a single data point at each iteration rather than a batch. The generalization of this problem to batch sampling and the corresponding algorithm and analysis are in Sec. 4.2 and the Appendix
+(Sec. B).
+
+Notation To formalize this objective, we let gt,i(θt−1) denote the gain of the i th point in P in round t ∈ [T] with respect to θt−1. Rather than seeking to optimize gains, we follow standard convention in online learning (Orabona, 2019) and consider the minimization of losses `t,i(θt−1) = 1 − gt,i(θt−1) ∈ [0, 1] instead.
+
+We let ξ0*, . . . , ξ*T denote the training noise at each round t. For any given realization of a subset of points S ⊂ P and noise ξ, define M(S, ξ) to be the deterministic function that returns the trained model θ on the set S. In the context of Alg. 1, the model θt at each iteration is given by θt = M(∪
+t τ=1Sτ , ξt), The loss at each time step can now be defined more rigorously as `t(θt−1) = `t M(∪
+t−1 τ=1Sτ , ξt−1). We will frequently abbreviate the loss vector at round t as `t(ξt−1) to emphasize the randomness over the training noise or simply as `t with the understanding that it is a function of the random variables S1*, . . . ,* St−1 and ξt−1.
+
+Since the expectation cannot be computed exactly a priori knowledge about the problem, we turn to an online learning strategy and aim to minimize the *regret* over T active learning iterations. More specifically, we follow the learning with prediction advice formulation where each data point (regardless of whether it has already been labeled) is considered an expert. The main idea is to pick the most informative data points, or experts in this context. At each iteration t, rather than picking a points to label in a deterministic way as do most greedy strategies, we propose using a probability distribution pt ∈ ∆t to sample the points instead, where ∆ = {p ∈ [0, 1]n :Pn j=1 pj = 1}. For the filtration Ft = σ(ξ0, S1*, . . . , ξ*t−1, St) with |St| = 1 for all t, note that the conditional expected loss at each iteration is ESt,ξt−1
+[`t,St
+(ξt−1)|Ft−1] = hpt, E ξt−1
+[`t(ξt−1)]i since pt is independent of ξt−1.
+
+Under this setting a natural first attempt at a formulation of regret is to define it as in the problem of learning with expert advice. To this end, we define the instantaneous regret rt,i to measure the expected loss under the sampling distribution pt relative to that of picking the i th point for a given realization of `t, i.e.,
+
+$$r_{t,i}=\widehat{\langle p_{t},\ell_{t}(\xi_{t-1})\rangle-\ell_{t,i}(\widehat{\xi_{t-1}})\rangle}.$$
+
+However, the sampling method and the definition of regret above are not well-suited for the problem of active learning because (i) pt may sample points that have already been labeled and (ii) the instantaneous regret for those points that are already sampled should be 0 so that we can define appropriately define regret over the unlabeled data points. Sleeping Experts and Dynamic Regret To resolve these challenges and ensure that we only sample from the pool of unlabeled data points, we generalize the prior formulation to one with *sleeping experts* (Saha et al.,
+2020; Luo & Schapire, 2015; Gaillard et al., 2014; Kleinberg et al., 2010). More concretely, let It,i ∈ {0, 1}
+denote whether expert i ∈ [n] is sleeping in round t. The sleeping expert problem imposes the constraint that It,i = 0 ⇒ pt,i = 0. For the data acquisition setting, we define It,i = 1{xi has not yet been labeled}, so that we do not sample already-labeled points. Then, the definition of instantenous regret becomes
+
+$$r_{t,i}=(\langle p_{t},\ell_{t}(\xi_{t-1})\rangle-\ell_{t,i}(\xi_{t-1}))\mathcal{I}_{t,i},$$
+
+and the regret over T iterations with respect to a competing sequence of samples i
+∗ 1
+, . . . , i∗T ∈ [n] is defined as
+
+$$\mathcal{R}(i_{1:T}^{*})=\sum_{t=1}^{T}\mathbb{E}_{\xi_{t-1}}[r_{t,i_{t}^{*}}]=\sum_{t=1}^{T}\left(\left(p_{t},\mathbb{E}_{\xi_{t-1}}[\ell_{t}(\xi_{t-1})]\right)-\mathbb{E}_{\xi_{t-1}}[\ell_{t,i_{t}^{*}}(\xi_{t-1})]\right)\mathbb{I}_{t,i_{t}^{*}}\tag{1}$$
+
+Our overarching goal is to minimize the maximum expected regret, which is at times referred to as the dynamic pseudoregret (Wei et al., 2017), relative to any sequence of samples i1*, . . . , i*T ∈ [n]
+
+$$\operatorname*{max}_{(i_{t})_{t\in[T]}}\mathbb{E}\left[{\mathcal{R}}(i_{1:T})\right].$$
+
+## 3 Method
+
+In this section we motivate and present Alg. 2, an efficient online learning algorithm with instance-dependent guarantees that performs well on predictable sequences while remaining resilient to adversarial ones. Additional implementation details are outlined in Sec. C of the supplementary.
+
+## 3.1 Background
+
+Algorithms for the prediction with sleeping experts problem have been extensively studied in literature (Gaillard et al., 2014; Luo & Schapire, 2015; Saha et al., 2020; Kleinberg et al., 2010; Shayestehmanesh et al., 2019; Koolen & Van Erven, 2015). These algorithms enjoy strong guarantees in the adversarial setting; however, they suffer from (i) sub-optimal regret bounds in predictable settings and/or (ii) high computational complexity.
+
+Our approach hinges on the observation that the active learning setting may not always be adversarial in practice, and if this is the case, we should be competitive with greedy approaches. For example, we may expect the informativeness of the points to resemble a predictable sequence plus random noise which models the random components of the training (see Sec. 2) at each time step. This (potential) predictability in the corresponding losses motivates an algorithm that can leverage predictions about the loss for the next time step to achieve lower regret by being more aggressive - akin to Greedy - when the losses do not vary significantly over time.
+
+## 3.2 Adaprod+
+
+To this end, we extend the Optimistic Adapt-ML-Prod algorithm (Wei et al., 2017) (henceforth, OAMLProd)
+to the active learning setting with batched plays where the set of experts (unlabeled data points) is changing and/or unknown in advance. Optimistic online learning algorithms are capable of incorporating predictions ˆ`t+1 for the loss in the next round `t+1 and guaranteeing regret as a function of the predictions' accuracy, i.e., as a function of PT
+t=1 ||`t − ˆ`t||2∞. Although we could have attempted to extend other optimistic approaches (Steinhardt & Liang, 2014; Orabona, 2019; Mohri & Yang, 2015; Rakhlin & Sridharan, 2013), the work of (Wei et al., 2017) ensures - to the best of our knowledge - the smallest regret in predictable environments when compared to related approaches.
+
+## Algorithm 2 Adaprod+
+
+1: For all i ∈ [n], initialize R1,i ← 0; C1,i ← 0; η0,(1,i) ←
+√log n; w0,(1,i) = 1; rˆ1,i = 0; 2: for each round t ∈ [T] do 3: At ← {i ∈ [n] : It,i = 1} {Set of awake experts, i.e., set of unlabeled data points}
+4: pt,i ←Ps∈[t]
+ηt−1,(s,i)wt−1,(s,i) exp(ηt−1,(s,i) rˆt,i) for each i ∈ At 5: pt,i ← pt,i/Pj∈At pt,j for each i ∈ At {Normalize}
+6: Adversary reveals `t and we suffer loss ˜`t = h`t, pti 7: For all i ∈ At, rt,i ← ˜`t − `t,i and Ct,i ← 0 8: For all i ∈ At and s ∈ [t], set Cs,i ← Cs,i + (ˆrt,i − rt,i)
+2 9: Get prediction rˆt+1 ∈ [−1, 1]n for next round (see Sec. 3.2)
+10: For all i ∈ At, set wt−1,(t,i) ← 1, ηt−1,(t,i) ←
+√log n, and for all s ∈ [t], set
+
+$$\eta_{t,(s,i)}\leftarrow\min\left\{\eta_{t-1,(s,i)},\frac{2}{3(1+\hat{r}_{t+1,i})},\sqrt{\frac{2\log(n)}{C_{s,i}}}\right\}\quad\text{and}$$ $$w_{t,(s,i)}\leftarrow\left(w_{t-1,(s,i)}\exp\left(\eta_{t-1,(s,i)}\,r_{t,i}-\eta_{t-1,(s,i)}^{2}(r_{t,i}-\hat{r}_{t,i})^{2}\right)\right)$$
+$\frac{1}{2}$ 4. 
+2ηt,(s,i)/ηt−1,(s,i)
+11: **end for**
+Our algorithm AdaProd+ is shown as Alg. 2. Besides its improved computational efficiency relative to OAMLProd in the active learning setting, AdaProd+ is also the result of a tightened analysis that leads to significant practical improvements over OAMLProd as shown in Fig. 5 of Sec. 5.5. Our insight is that our predictions can be leveraged to improve practical performance by allowing larger learning rates to be used without sacrificing theoretical guarantees (Line 10 of Alg. 2). Empirical comparisons with Adapt-ML-Prod and other state-of-the-art algorithms can be found in Sec. 5.5.
+
+Generating Predictions Our approach can be used with general predictors ˆ`t for the true loss `t at round t, however, to obtain bounds in terms of the temporal variation in the losses, we use the most recently observed loss as our prediction for the next round, i.e., ˆ`t = `t−1. A subtle issue is that our algorithm requires a prediction rˆt ∈ [−1, 1]n for the instantaneous regret at round t, i.e., rˆt = hpt, ˆ`ti − ˆ`t, which is not available since pt is a function of rt. To achieve this, we follow (Wei et al., 2017) and define the mapping rˆt : α 7→ (α − ˆ`t) ∈ [−1, 1]n and perform a binary search over the update rule in Lines 4-5 of Alg. 2 so that α ∈ [0, 1] is such that α = hpt(rˆt(α)),
+ˆ`ti, where pt(rˆt(α)) is the distribution obtained when rˆt(α) is used as the optimistic prediction in Lines 4-5. The existence of such an α follows by applying the intermediate value theorem to the continuous update.
+
+## 3.3 Back To Active Learning
+
+To unify AdaProd+ with Alg. 1, observe that we can define the Acquire function to be a procedure that at time step t first samples a point by sampling with respect to probabilities pt, obtains the (user-specified) losses `t with respect to the model θt−1, and passes them to Alg. 2 as if they were obtained from the adversary (Line 6). This generates an updated probability distribution pt+1 and we iterate.
+
+To generalize this approach to sampling a batch of bt points, we build on ideas from (Uchiya et al., 2010).
+
+Here, we provide an outline of this procedure; the full details along with the code are provided in the supplementary (Sec. B). At time t, we apply a capping algorithm (Uchiya et al., 2010) to the probability pt generated by AdaProd+ - which takes O(nt log nt) time, where nt ≤ n is the number of remaining unlabeled points at iteration t - to obtain a modified distribution p˜t satisfying maxi p˜t,i ≤ 1/bt. This projection to the capped simplex ensures that the scaled version of p˜t, pˆt,i = btp˜t,i, satisfies pˆt,i ∈ [0, 1] and Pj pˆt,j = bt. Now the challenge is to sample exactly bt distinct points according to probability pˆt. To achieve this, we use a dependent randomized rounding scheme (Gandhi et al., 2006) (Alg. 4 in supplementary) that runs in O(nt)
+time. The overall computational overhead of batch sampling is O(nt log nt).
+
+## 3.4 Flexibility Via Proprietary Loss
+
+We end this section by underscoring the generality of our approach, which can be applied *off-the-shelf with any* definition of informativeness measure that defines the loss ` ∈ [0, 1]n, i.e., 1 - informativeness. For example, our framework can be applied with the *uncertainty metric* as defined in Sec. 2 by defining the losses to be
+`t,i = maxj∈[k] fθt−1
+(xi)j . As we show in Sec. 5.4, we can also use other popular notions of informativeness such as Entropy (Ren et al., 2020) and the BALD metrics (Gal et al., 2017) to obtain improved results relative to greedy selection. This flexibility means that our approach can always be instantiated with any state-of-the-art notion of informativeness, and consequently, can scale with future advances in appropriate notions of informativeness widely studied in literature.
+
+## 4 Analysis
+
+In this section, we present the theoretical guarantees of our algorithm in the learning with sleeping experts setting. Our main result is an instance-dependent bound on the dynamic regret of our approach in the active learning setting. We focus on the key ideas in this section and refer the reader to the Sec. A of the supplementary for the full proofs and generalization to the batch setting.
+
+The main idea of our analysis is to show that AdaProd+ (Alg. 2), which builds on Optimistic Adapt-MLProd (Wei et al., 2017), retains the adaptive regret guarantees of the time-varying variant of their algorithm without having to know the number of experts a priori (Wei et al., 2017). Inspired by AdaNormalHedge (Luo
+& Schapire, 2015), we show that our algorithm can efficiently ensure adaptive regret by keeping track of PT
+t∈1 nt ≤ nt experts at time step t, where nt denotes the number of unlabeled points remaining, nt =Pn i=1 It,i, rather than nt experts as in prior work. This leads to efficient updates and applicability to the active learning setting where the set of unlabeled points remaining (experts) significantly shrinks over time.
+
+Our second contribution is an improved learning rate schedule (Line 10 of Alg. 2) that arises from a tightened analysis that enables us to get away with strictly larger learning rates without sacrificing any of the theoretical guarantees. For comparison, the learning rate schedule of (Wei et al., 2017) would be ηt,(s,i) = min{1/4,p2 log(n)/(1 + Cs,i)} in the context of Alg. 2. It turns out that the dampening factor of 1 from the denominator can be removed, and the upper bound of 1/4 is overly-conservative and can instead be replaced by min{ηt−1,(s,i), 2/ (3(1 + ˆrt+1,i))}. This means that we can leverage the predictions at round t to set the threshold in a more informed way. Although this change does not improve (or change) the worst-case regret bound asymptotically, our results in Sec. 5 (see Fig. 5) show that it translates to significant practical improvements in the active learning setting.
+
+## 4.1 Point Sampling
+
+We highlight the two main results here and refer to the supplementary for the full analysis and proofs. The lemma below bounds the *adaptive regret* of AdaProd+, which concerns the cumulative regret over a time interval [t1, t2], with respect to Ct2,(t1,i) =Pt2 t=t1
+(rt,i − rˆt,i)
+2.
+
+Lemma 1 (Adaptive Regret of AdaProd+). For any t1 ≤ t2 and i ∈ [n], Alg. 2 *ensures that*
+
+$$\sum_{t=t_{1}}^{t_{2}}r_{t,i}\leq\mathcal{O}\left(\log n+\log\log n+(\sqrt{\log n}+\log\log n)\sqrt{C_{t_{2},(t_{1},i)}}\right),$$
+
+where Ct2,(t1,i) =Pt2 t=t1
+(rt,i − rˆt,i)
+2 and rt,i = (h`t, pti − `t,i)It,i is the instantaneous regret of i ∈ [n] *at time* t and rˆt,i = (h ˆ`t, pti − ˆ`t,i)It,i *is the predicted instantenous regret as a function of the optimistic loss vector* ˆ`t *prediction.*
+It turns out that there is a deep connection between dynamic and adaptive regret, and that an adaptive regret bound implies a dynamic regret bound (Luo & Schapire, 2015; Wei et al., 2017). The next theorem follows by an invocation of Lemma 1 to multiple (O(*T /B*)) time blocks of length B and additional machinery to bound the regret per time block. The bound on the expected dynamic regret is a function of the sum of the prediction error of rˆt which is a function of our loss prediction `t, and DT , which is the drift in the expected regret
+
+$\mathcal{V}_{T}=\sum_{t\in[T]}\|r_{t}-\hat{r}_{t}\|_{\infty}^{2}\quad\text{and}\quad\mathcal{D}_{T}=\sum_{t\in[T]}\|\mathbb{E}\left[r_{t}\right]-\mathbb{E}\left[r_{t-1}\right]\|_{\infty},$
+where the expectation E [rt] = E [(hpt, `t(ξt−1)i−`t(ξt−1)) It] is taken over all the relevant random variables, i.e., the training noise ξ0:t−1 and the algorithm's actions up to point t, S1:t, with  denoting the Hadamard
+(entry-wise) product. We note that by Hölder's inequality, VT ≤ 4Pt∈[T]
+||`t − ˆ`t||2∞, which makes it easier to view the quantity as the error between the loss predictions ˆ`t and the realized ones `t.
+
+Theorem 2 (Dynamic Regret). AdaProd+ *takes at most* O˜(tnt)
+1*time for the* t th update and for batch size b = 1 for all t ∈ [T], guarantees that over T *steps,*
+
+$$\operatorname*{max}_{(i_{t})_{t\in[T]}}\mathbb{E}\left[\mathcal{R}(i_{1:T})\right]\leq\hat{\mathcal{O}}\left(\sqrt[3]{\mathbb{E}\left[\mathcal{V}_{T}\right]\mathcal{D}_{T}T\log n}+\sqrt{\mathcal{D}_{T}T\log n}\right),$$
+
+where Oˆ(·) *suppresses* log T *factors.*
+Note that in scenarios where Greedy fails, i.e., instances where there is a high amount of training noise, the expected variance of the losses with respect to the training noise E [VT ] may be on the order of T. However, even in high noise scenarios, the drift in the *expectation* of the regret may be sublinear, e.g., a distribution of losses that is fixed across all iterations E [`1] = *· · ·* = E [`T ], i.e., a stationary distribution, but with high variance E [k`t − E [`t]k]. This means that sublinear dynamic regret is possible with AdaProd+ even in noisy environments, since then Dt = o(T), E [VT ] = Θ(T) and p3 E [VT ] DT T log n +
+√DT T log n = o(T).
+
+## 4.2 Batch Sampling
+
+In the previous subsection, we established bounds on the regret in the case where we sampled a single point in each round t. Here, we establish bounds on the performance of Alg. 2 with respect to sampling a batch of b ≥ 1 points St in each round t without any significant modifications to the presented method. To do so, we make the mild assumption that the time horizon T, the size of the data set n, and the batch size b are so that maxi∈[n] pt,i ≤ 1/b for all t ∈ [T]. We can then define the scaled probabilities ρt,i = bpt,i and sample according to ρt,i. As detailed in the Appendix (Sec. B), there is a linear-time randomized rounding scheme for picking exactly b samples so that each sample is picked with probability ρt,i. Note that ρt,i ∈ [0, 1] for all t and i ∈ [n] by the assumption.
+
+1We use O˜(·) to suppress log T and log n factors.
+For batch sampling, we override the definition of rt,i and define it with respect to the sampling distribution ρ so that
+
+$$r_{t,i}=\left({\frac{\langle\rho_{t},\ell_{t}(\xi_{t-1})\rangle}{b}}-\ell_{t,i}(\xi_{t-1})\right){\mathcal{I}}_{t,i}.$$
+
+Now let S
+∗
+1
+, . . . , S
+∗
+T be a competing sequence of samples such that |S∗
+t | = b. Then, the expected regret with respect to our samples St ∼ ρt over T iterations is expressed by.
+
+$${\mathcal{R}}({\mathcal{S}}_{1:T}^{*})=\sum_{t=1}^{T}\sum_{j=1}^{b}\mathbb{E}\,\varepsilon_{t-1}[r_{t,{\mathcal{S}}_{t j}^{*}}],$$
+
+where S
+∗
+tj ∈ [n] denotes the j th sample of the competitor at step t. The next theorem generalizes Theorem 2 to batch sampling, which comes at the cost of a factor of b in the regret.
+
+Theorem 3 (Dynamic Regret). AdaProd+ with batch sampling of b points guarantees that over T *steps,*
+
+$$\operatorname*{max}_{(S_{t})_{t\in[T]}:S_{t}=b\,\forall t}\mathbb{E}\left[\mathcal{R}(S_{1:T})\right]\leq\hat{\mathcal{O}}\left(b\sqrt[3]{\mathbb{E}\,\left[\mathcal{V}_{T}\right]\,\mathcal{D}_{T}T\log n}+b\sqrt{\mathcal{D}_{T}T\log n}\right).$$
+
+We note that the assumption imposed in this subsection is not restrictive in the context of active learning where we assume the pool of unlabeled samples is large and that we only label a small batch at a time, i.e., n  b. In our experimental evaluations, we verified that it held for all the scenarios and configurations presented in this paper (Sec. 5 and Sec. C of the appendix). Additionally, by our sleeping expert formulation, as soon as the probability of picking a point pt,i starts to become concentrated, we will sample point i and set pt,i = 0 with very high probability. Hence, our algorithm inherently discourages the concentration of the probabilities at any one point. Relaxing this assumption rigorously is an avenue for future work.
+
+## 5 Results
+
+In this section, we present evaluations of our algorithm and compare the performance of its variants on common vision tasks. The full set of results and our codebase be found in the supplementary material
+(Sec. C). Our evaluations across a diverse set of configurations and benchmarks demonstrate the practical effectiveness and reliability of our method. In particular, they show that our approach (i) is the only one to significantly improve on the performance of uniform sampling across all scenarios, (ii) reliably outperforms competing approaches even with the intuitive Uncertainty metric (Fig. 2,3), (iii) when instantiated with other metrics, leads to strict improvements over greedy selection (Fig. 4), and (iv) outperforms modern algorithms for learning with expert advice (Fig. 5).
+
+## 5.1 Setup
+
+We compare our active learning algorithm Alg. 2 (labeled Ours) with the *uncertainty* loss described in Sec. 2; Uncertainty: greedy variant of our algorithm with the same measure of informativeness; Entropy: greedy approach that defines informativeness by the entropy of the network's softmax output; Coreset: clusteringbased active learning algorithm of (Sener & Savarese, 2017; Geifman & El-Yaniv, 2017); BatchBALD:
+approach based on the mutual information of points and model parameters (Kirsch et al., 2019); and Uniform sampling. We implemented the algorithms in Python and used the PyTorch (Paszke et al., 2017) library for deep learning.
+
+We consider the following popular vision data sets trained on modern convolutional networks:
+1. **FashionMNIST**(Xiao et al., 2017): 60, 000 grayscale images of size 28 × 28 2. **CIFAR10** (Krizhevsky et al., 2009): 50, 000 color images (32 × 32) each belonging to one of 10 classes 3. **SVHN** (Netzer et al., 2011): 73, 257 real-world images (32 × 32) of digits taken from Google Street View 4. **ImageNet** (Deng et al., 2009): more than 1.2 million images spanning 1000 classes We used standard convolutional networks for training FashionMNIST (Xiao et al., 2017) and SVHN (Chen, 2020), and the CNN5 architecture (Nakkiran et al., 2019) and residual networks (resnets) (He et al., 2016)
+for our evaluations on CIFAR10 and ImageNet. The networks were trained with optimized hyper-parameters from the corresponding reference. All results were averaged over 10 trials unless otherwise stated. The full set of hyper-parameters and details of each experimental setup are provided in the supplementary material
+(Sec. C).
+
+Computation Time Across all data sets, our algorithm took at most 3 minutes per update step. This was comparable (within a factor of 2) to that required by Uncertainty and Entropy. However, relative to more sophisticated approaches, Ours was up to ≈ 12.3x faster than Coreset, due to expensive pairwise distance computations involved in clustering, and up to ≈ 11x faster than BatchBALD, due to multiple (≥ 10)
+forward passes over the entire data on a network with dropout required for its Bayesian approximation (Kirsch et al., 2019); detailed timings are provided in the supplementary.
+
+5.2 Evaluations on Vision Tasks
+
+![8_image_0.png](8_image_0.png) 
+Uniform
+
+Uniform 
+Figure 2: Evaluations on popular computer vision benchmarks trained on convolutional neural networks. Our algorithm consistently achieves higher performance than uniform sampling and outperforms or matches competitors on all scenarios. This is in contrast to the highly varying performance of competing methods. Shaded regions correspond to values within one standard deviation of the mean.
+
+As our initial experiment, we evaluate and compare the performance of our approach on benchmark computer vision applications. Fig. 2 depicts the results of our experiments on the data sets evaluated with respect to test accuracy and test loss of the obtained network. For these experiments, we used the standard methodology (Ren et al., 2020; Gal et al., 2017) of retraining the network from scratch as the option in Alg. 1. Note that for all data sets, our algorithm (shown in red) consistently outperforms uniform sampling, and in fact, also leads to reliable and strict improvements over existing approaches for all data sets. On ImageNet, we consistently perform better than competitors when it comes to test accuracy and loss. This difference is especially notable when we compare to greedy approaches that are outpaced by Uniform by up to ≈ 5% test accuracy. Our results support the widespread reliability and scalability of AdaProd+, and show promise for its effectiveness on even larger models and data sets.
+
+## 5.3 Robustness Evaluations
+
+Next, we investigate the robustness of the considered approaches across varying data acquisition configurations evaluated on *a fixed data set*. To this end, we define a data acquisition configuration as the tuple
+(option, nstart*, b, n*end) where option is either Scratch or Incr in the context of Alg. 1, nstart is the number of initial points at the first step of the active learning iteration, b is the fixed label budget per iteration, and nend is the number of points at which the active learning process stops. Intuitively, we expect robust active learning algorithms to be resilient to changes in the data acquisition configuration and to outperform uniform sampling in a configuration-agnostic way.
+
+![9_image_0.png](9_image_0.png)
+
+Figure 3: Our evaluations on the FashionMNIST data set with varying data acquisition configurations and Incr and Scratch - (Option, nstart*, b, n*end). All figures except for (f) depict the test accuracy. The performance of competing methods varies greatly across configurations even when the data set is fixed.
+Fig. 3 shows the results of our experiments on FashionMNIST. From the figures, we can see that our approach performs significantly better than the compared approaches in terms of both test accuracy and loss in all evaluated configurations. In fact, the compared methods' performance fluctuates wildly, supporting our premise about greedy acquisition. For instance, we can see that the uncertainty metric in Fig. 3 fares worse than naive uniform sampling in (a), but outperforms Uniform in settings (d) and (e); curiously, in (c), it is only better after an interesting cross-over point towards the end.
+
+This inconsistency and sub-uniform performance is even more pronounced for the Entropy and Coreset algorithms that tend to perform significantly worse - up to -7% and -4% (see (a) and (e) in Fig. 3) absolute test accuracy when compared to that of our method and uniform sampling, respectively. We postulate that the poor performance of these competing approaches predominantly stems from their inherently greedy acquisition of data points in a setting with significant randomness as a result of stochastic training and data augmentation, among other elements. In contrast, our approach has provably low-regret with respect to the data acquisition objective, and we conjecture that this property translates to consistent performance across varying configurations and data sets.
+
+## 5.4 Boosting Prior Approaches
+
+Despite the favorable results presented in the previous subsections, a lingering question still remains: to what extent is our choice of the loss as the uncertainty metric responsible for the effectiveness of our approach?
+
+More generally, can we expect our algorithm to perform well off-the-shelf - and even lead to improvements over greedy acquisition - with other choices for the loss? To investigate, we implement three variants of our approach, Ours (Uncertainty), Ours (Entropy), and Ours (BALD) that are instantiated with losses defined in terms of uncertainty, entropy, BALD metrics respectively, and compare to their corresponding greedy variants on SVHN and FashionMNIST. We note that the uncertainty loss corresponds to `t,i = maxj ft(xi)j ∈ [0, 1] and readily fits in our framework. For the Entropy and BALD loss, the application is only slightly more nuanced in that we have to be careful that losses are bounded in the interval
+[0, 1]. This can be done by scaling the losses appropriately, e.g., by normalizing the losses for each round to be in [0, 1] or scaling using a priori knowledge, e.g., the maximum entropy is log(k) for a classification task with k classes.
+
+![10_image_0.png](10_image_0.png)
+
+Figure 4: The performance of our algorithm when instantiated with informativeness metrics from prior work compared to that of existing greedy approaches. Using AdaProd+ off-the-shelf with the corresponding metrics took only a few lines of code and lead to strict gains in performance on all evaluated benchmark data sets. 
+The performance of the compared algorithms are shown in Fig. 4. Note that for all evaluated data sets and metrics, our approach fares significantly better than its greedy counterpart. In other words, applying AdaProd+ off-the-shelf with existing informativeness measures leads to strict improvements compared to their greedy variants. As seen from Fig. 4, our approach has potential to yield up to a 5% increase in test accuracy, and in all cases, achieves significantly lower test loss.
+
+![10_image_1.png](10_image_1.png) 
+Figure 5: Comparisons with competing algorithms for learning with prediction advice on the SVHN (first row)
+and CIFAR10 (second row) data sets. In both scenarios, AdaProd∗outperforms the compared algorithms, and significantly improves on its predecessor, Optimistic AMLProd, on both data sets and all evaluated metrics.
+
+## 5.5 Comparison To Existing Expert Algorithms
+
+In this section, we consider the performance of AdaProd+ relative to that of state-of-the-art algorithms for learning with prediction advice. In particular, compare our approach to Optimistic AMLProd (Wei et al.,
+2017), AdaNormalHedge(.TV) (Luo & Schapire, 2015), and Squint(.TV) (Koolen & Van Erven, 2015)
+on the SVHN and CIFAR10 data sets. Fig. 5 depicts the results of our evaluations. As the figures show, our approach outperforms the compared approaches across both data sets in terms of all of the metrics considered.
+
+AdaNormalHedge comes closest to our method in terms of performance. Notably, the improved learning rate schedule (see Sec. 4) of AdaProd+ compared to that of Optimistic AMLProd enables up to 3%
+improvements on test error on, e.g., SVHN and 2% on CIFAR10.
+
+## 6 Conclusion
+
+In this paper, we introduced a low-regret active learning approach based on formulating the problem of data acquisition as that of prediction with experts. Building on our insights on the existing research gap in active learning, we introduced an efficient algorithm with performance guarantees that is tailored to achieve low regret on predictable instances while remaining resilient to adversarial ones. Our empirical evaluations on large-scale real-world data sets and architectures substantiate the reliability of our approach in outperforming naive uniform sampling and show that it leads to consistent and significant improvements over existing work. Our analysis and evaluations suggest that AdaProd+ can be applied off-the-shelf with existing informativeness measures to improve upon greedy selection, and likewise can scale with future advances in uncertainty or informativeness quantification. In this regard, we hope that this work can contribute to the advancement of reliably effective active learning approaches that can one day become an ordinary part of every practitioner's toolkit, just like Adam and SGD have for stochastic optimization.
+
+## References
+
+Jordan Ash. Badge. https://github.com/JordanAsh/badge, 2021. 27, 28 Jordan T Ash, Chicheng Zhang, Akshay Krishnamurthy, John Langford, and Alekh Agarwal. Deep batch active learning by diverse, uncertain gradient lower bounds. *arXiv preprint arXiv:1906.03671*, 2019. 1, 3, 23, 27, 28, 29 Cenk Baykal, Lucas Liebenwein, Igor Gilitschenski, Dan Feldman, and Daniela Rus. Data-dependent coresets for compressing neural networks with applications to generalization bounds. arXiv preprint arXiv:1804.05345, 2018. 25 William H Beluch, Tim Genewein, Andreas Nürnberger, and Jan M Köhler. The power of ensembles for active learning in image classification. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 9368–9377, 2018. 1 Omar Besbes, Yonatan Gur, and Assaf Zeevi. Stochastic multi-armed-bandit problem with non-stationary rewards. *Advances in neural information processing systems*, 27, 2014. 21 Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners.
+
+arXiv preprint arXiv:2005.14165, 2020. 1 Nicolo Cesa-Bianchi and Gábor Lugosi. *Prediction, learning, and games*. Cambridge university press, 2006.
+
+16 A. Chen. Pytorch playground. https://github.com/aaron-xichen/pytorch-playground, 2020. 9, 25 Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In *2009 IEEE conference on computer vision and pattern recognition*, pp. 248–255. Ieee, 2009. 8 Melanie Ducoffe and Frederic Precioso. Adversarial active learning for deep networks: a margin based approach. *arXiv preprint arXiv:1802.09841*, 2018. 1 Sayna Ebrahimi, William Gan, Kamyar Salahi, and Trevor Darrell. Minimax active learning. arXiv preprint arXiv:2012.10467, 2020. 1, 3 Xin Feng, Youni Jiang, Xuejiao Yang, Ming Du, and Xin Li. Computer vision algorithms and hardware implementations: A survey. *Integration*, 69:309–320, 2019. 1 Pierre Gaillard, Gilles Stoltz, and Tim Van Erven. A second-order bound with excess losses. In Conference on Learning Theory, pp. 176–196. PMLR, 2014. 4, 15, 16, 18, 19, 26 Yarin Gal, Riashat Islam, and Zoubin Ghahramani. Deep bayesian active learning with image data. In International Conference on Machine Learning, pp. 1183–1192. PMLR, 2017. 1, 2, 6, 9 Rajiv Gandhi, Samir Khuller, Srinivasan Parthasarathy, and Aravind Srinivasan. Dependent rounding and its applications to approximation algorithms. *Journal of the ACM (JACM)*, 53(3):324–360, 2006. 6 Yonatan Geifman and Ran El-Yaniv. Deep active learning over the long tail. *arXiv preprint arXiv:1711.00941*,
+2017. 2, 8 Daniel Gissin and Shai Shalev-Shwartz. Discriminative active learning. *arXiv preprint arXiv:1907.06347*,
+2019. 23 Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. 9, 25 Andreas Kirsch, Joost Van Amersfoort, and Yarin Gal. Batchbald: Efficient and diverse batch acquisition for deep bayesian active learning. *arXiv preprint arXiv:1906.08158*, 2019. 8, 9 Robert Kleinberg, Alexandru Niculescu-Mizil, and Yogeshwer Sharma. Regret bounds for sleeping experts and bandits. *Machine learning*, 80(2):245–272, 2010. 4 Wouter M Koolen and Tim Van Erven. Second-order quantile methods for experts and combinatorial games.
+
+In *Conference on Learning Theory*, pp. 1155–1175. PMLR, 2015. 4, 12, 15, 27 Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009. 8 Lucas Liebenwein. Torchprune. https://github.com/lucaslie/torchprune, 2021. 25 Lucas Liebenwein, Cenk Baykal, Harry Lang, Dan Feldman, and Daniela Rus. Provable filter pruning for efficient neural networks. *arXiv preprint arXiv:1911.07412*, 2019. 25 Haipeng Luo. Interval Regret. https://haipeng-luo.net/courses/CSCI699/lecture9.pdf, 2017. [Online; accessed November-2020]. 27 Haipeng Luo and Robert E Schapire. Achieving all with no parameters: Adanormalhedge. In *Conference on* Learning Theory, pp. 1286–1304, 2015. 4, 6, 7, 12, 15, 19, 27 Mehryar Mohri and Scott Yang. Accelerating optimization via adaptive prediction. *arXiv preprint* arXiv:1509.05760, 2015. 5 Hariank Muthakana. *Uncertainty and diversity in deep active image classification*. PhD thesis, Carnegie Mellon University Pittsburgh, PA, 2019. 1, 2, 3, 23 Preetum Nakkiran, Gal Kaplun, Yamini Bansal, Tristan Yang, Boaz Barak, and Ilya Sutskever. Deep double descent: Where bigger models and more data hurt. *arXiv preprint arXiv:1912.02292*, 2019. 9, 25 Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng. Reading digits in natural images with unsupervised feature learning. 2011. 8 Francesco Orabona. A modern introduction to online learning. *arXiv preprint arXiv:1912.13213*, 2019. 3, 5 Pankajj. Fashion MNIST with PyTorch. https://www.kaggle.com/pankajj/
+fashion-mnist-with-pytorch-93-accuracy, 2018. [Online; accessed November-2020]. 25 Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. 2017. 8 Alexander Rakhlin and Karthik Sridharan. Online learning with predictable sequences. In Conference on Learning Theory, pp. 993–1019. PMLR, 2013. 5 Pengzhen Ren, Yun Xiao, Xiaojun Chang, Po-Yao Huang, Zhihui Li, Xiaojiang Chen, and Xin Wang. A
+survey of deep active learning. *arXiv preprint arXiv:2009.00236*, 2020. 1, 6, 9, 23 Aadirupa Saha, Pierre Gaillard, and Michal Valko. Improved sleeping bandits with stochastic action sets and adversarial rewards. In *International Conference on Machine Learning*, pp. 8357–8366. PMLR, 2020. 4 Ozan Sener and Silvio Savarese. Active learning for convolutional neural networks: A core-set approach.
+
+arXiv preprint arXiv:1708.00489, 2017. 1, 2, 3, 8, 23, 29 Hamid Shayestehmanesh, Sajjad Azami, and Nishant A Mehta. Dying experts: Efficient algorithms with optimal regret bounds. *arXiv preprint arXiv:1910.13521*, 2019. 4 Li Shen, Laurie R Margolies, Joseph H Rothstein, Eugene Fluder, Russell McBride, and Weiva Sieh. Deep learning to improve breast cancer detection on screening mammography. *Scientific reports*, 9(1):1–12, 2019.
+
+1 Jacob Steinhardt and Percy Liang. Adaptivity and optimism: An improved exponentiated gradient algorithm.
+
+In *International Conference on Machine Learning*, pp. 1593–1601. PMLR, 2014. 5 Taishi Uchiya, Atsuyoshi Nakamura, and Mineichi Kudo. Algorithms for adversarial bandit problems with multiple plays. In *International Conference on Algorithmic Learning Theory*, pp. 375–389. Springer, 2010.
+
+6, 23, 24 Manfred K Warmuth and Dima Kuzmin. Randomized online pca algorithms with regret bounds that are logarithmic in the dimension. *Journal of Machine Learning Research*, 9(Oct):2287–2320, 2008. 24 Chen-Yu Wei, Yi-Te Hong, and Chi-Jen Lu. Tracking the best expert in non-stationary stochastic environments.
+
+arXiv preprint arXiv:1712.00578, 2017. 4, 5, 6, 7, 12, 15, 16, 19, 20, 21, 23, 26, 27 Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms. *arXiv preprint arXiv:1708.07747*, 2017. 8, 9 In this supplementary material, we provide the full proofs of our analytical results (Sec. A), implementation details of our full algorithm capable of batch sampling (Sec. B), details of experiments and additional evaluations (Sec. C), and a discussion of limitations and future work (Sec. D).
+
+## A Analysis
+
+In this section, we present the full proofs and technical details of the claims made in Sec. 4. The outline of our analysis as follows. We first consider the *base* AdaProd+ algorithm (shown as Alg. 3), which is nearly the same algorithm as AdaProd+, with the exception that it is meant to be a general purpose algorithm for a setting with K experts (K is not necessarily equal to the number of points n). We show that this algorithm retains the original regret guarantees with respect to a stationary competitor of Adapt-ML-Prod.
+
+We then consider the thought experiment where we use this standard version of our algorithm with the K = nT sleeping experts reduction shown in (Wei et al., 2017; Gaillard et al., 2014) to obtain guarantees for adaptive regret. This leads us to the insight (as in (Luo & Schapire, 2015; Koolen & Van Erven, 2015)) that we do not need to keep track of the full set of K experts, and can instead keep track of a much smaller (but growing) set of experts in an efficient way without compromising the theoretical guarantees.
+
+Algorithm 3 Base AdaProd+
+1: For all i ∈ [K], Ci,0 ← 0; η0,i ←plog(K)/2; w0,i = 1; rˆ1,i = 0; 2: for each round t ∈ [T] do 3: pt,i ← ηt−1,iwt−1,i exp(ηt−1,i rˆt,i) for each i ∈ [K]
+4: pt,i ← pt,i/Pj∈[K]
+pt,j for each i ∈ [K] {Normalize}
+5: Adversary reveals `t and we suffer loss ˜`t = h`t, pti 6: For all i ∈ [K], set rt,i ← ˜`t − `t,i 7: For all i ∈ [K], set Ct,i ← Ct−1,i + (ˆrt,i − rt,i)
+2 8: Get prediction rˆt+1 ∈ [−1, 1]K for next round (see Sec. 3.2)
+9: For all i ∈ [K], update the learning rate
+
+$$\eta_{t,i}\leftarrow\operatorname*{min}\left\{\eta_{t-1,i},{\frac{2}{3(1+{\hat{r}}_{t+1,i})}},{\sqrt{\frac{\log(K)}{C_{t,i}}}}\right\}$$
+
+$\mathbf{1}/2$
+$\mathbf{a}\cdot\mathbf{a}=0$
+$\hat{\imath}$, $\hat{\imath}$. 
+$\overline{\phantom{\rule{1.00pt}{0ex}}\phantom{\rule{1.00pt}{0ex}}}$ . 
+)
+10: For all i ∈ [K], update the weights wt,i ←wt−1,i exp ηt−1,irt,i − η 2 t−1,i(rt,i − rˆt,i)
+2ηt,i/ηt−1,i 11: **end for**
+
+## A.1 Recovering Optimistic Adapt-Ml-Prod Guarantees For Alg. 3
+
+We begin by observing that Alg. 3 builds on the standard Optimistic Adapt-ML-Prod algorithm (Wei et al.,
+2017) by using a different initialization of the variables (Line 1) and upper bound imposed on the learning rates (as in Alg. 2, and analogously, in Line 9 of Alg. 3). Hence, the proof is has the same structure as (Wei et al., 2017; Gaillard et al., 2014), and we prove all of the relevant claims (at times, in slightly different ways)
+below for clarity and completeness. We proceed with our key lemma about the properties of the learning rates.
+
+Lemma 4 (Properties of Learning Rates). Assume that the losses are bounded `t ∈ [0, 1]K *and that the* learning rates ηt,i are set according to Line 9 of Alg. 3 for all t ∈ [T] and i ∈ [K]*, i.e.,*
+
+$$\eta_{t,i}\leftarrow\operatorname*{min}\left\{\eta_{t-1,i},{\frac{2}{3(1+{\hat{r}}_{t+1,i})}},{\sqrt{\frac{\log(K)}{C_{t,i}}}}\right\}.$$
+$$x\geq0,$$
+.
+Then, all of the following hold for all t ∈ [T] and i ∈ [K]:
+1. ηt,i(rt+1,i − rˆt+1,i) − η 2 t,i(rt+1,i − rˆt+1,i)
+
+$$\mathrm{{tg}}\left(1+\eta_{t,i}(r_{t+1,i}-\hat{r}_{t+1,i})\right),$$
+
+2. x ≤ x ηt,i/ηt+1,i + 1 −
+ηt+1,i ηt,i∀x ≥ 0,
+
+$$3.~\frac{\eta_{t,i}-\eta_{t+1,i}}{\eta_{t,i}}\leq\log(\eta_{t,i}/\eta_{t+1,i})~.$$
+
+Proof. For the first claim, observe that the range of admissible values in the original Prod inequality (CesaBianchi & Lugosi, 2006)
+
+$$\forall x\geq-1/2\quad x-x^{2}\leq\log(1+x)$$
+
+can be improved2to ∀x ≥ −2/3. Now let x = ηt,i(rt+1,i − rˆt+1,i), and observe that since `t ∈ [0, 1]K, we have rt+1,i = hpt+1, `t+1i − `t+1 ∈ [−1, 1], and so
+
+$$\begin{array}{l}{{x\geq\eta_{t,i}(-1-\hat{r}_{t+1,i})=-\eta_{t,i}(1+\hat{r}_{t+1,i})}}\\ {{\geq-2/3,}}\end{array}$$
+
+where in the last inequality we used the upper bound on ηt,i ≤ 2/(3(1 + ˆrt+1,i) which holds by definition of the learning rates.
+
+For the second claim, recall Young's inequality3 which states that for non-negative *a, b*, and p ≥ 1,
+
+$$a b\leq a^{p}/p+b^{p/(p-1)}(1-1/p).$$
+
+For our application, we set a = x, b = 1, and p = ηt,i/ηt+1,i. Observe that p is indeed greater than 1 since the learning rates are non-increasing over time (i.e., ηt+1,i ≤ ηt,i for all t and i) by definition. Applying Young's inequality, we obtain
+
+$$x\leq x^{\eta_{t,i}/\eta_{t+1,i}}(\eta_{t+1,i}/\eta_{t,i})+\frac{\eta_{t,i}-\eta_{t+1,i}}{\eta_{t,i}},$$
+
+and the claim follows by the fact that the learning rates are non-increasing.
+
+For the final claim, observe that the derivative of log(x) is 1/x, and so by the mean value theorem we know that there exists c ∈ [ηt+1,i, ηt,i] such that
+
+$$\frac{\log(\eta_{t,i})-\log(\eta_{t+1,i})}{\eta_{t,i}-\eta_{t+1,i}}=\frac{1}{c}.$$
+
+Rearranging and using c ≤ max{ηt,i, ηt+1,i} = ηt,i, we obtain
+
+$$\log(\eta_{t,i}/\eta_{t+1,i})=\frac{\eta_{t,i}-\eta_{t+1,i}}{c}\geq\frac{\eta_{t,i}-\eta_{t+1,i}}{\eta_{t,i}}.$$
+
+Having established our helper lemma, we now proceed to bound the regret with respect to a single expert as in (Wei et al., 2017; Gaillard et al., 2014). The main statement is given by the lemma below.
+
+2By inspection of the root of the function g(x) = log(1 + x) − x + x 2 closest to x = −1/2, which we know exists since g(−1/2) > 0 while g(−1) < 0.
+
+3This follows by taking logarithms and using the concavity of the logarithm function.
+$\square$
+Lemma 5 (Base AdaProd+ Static Regret Bound). The static regret of Alg. 3 *with respect to any expert* i ∈ [K],Pt rt,i*, is bounded by*
+
+$${\mathcal{O}}\left(\log K+\log\log T+({\sqrt{\log K}}+\log\log T){\sqrt{C_{T,i}}}\right),$$
+
+where C*T ,i* =Pt∈[T]
+(rt,i − rˆt,i)
+2.
+
+Proof. Consider Wt =Pi∈[K] wt,i to be the sum of *potentials* at round t. We will first show an upper bound on the potentials and then show that this sum is an upper bound on the regret of any expert (plus some additional terms). Combining the upper and lower bounds will lead to the statement of the lemma. To this end, we first show that the sum of potentials does not increase too much from round t to t + 1. To do so, we apply (2) from Lemma 4 with x = wt+1,i to obtain for each wt+1,i
+
+$$w_{t+1,i}\leq w_{t+1,i}^{\eta_{t,i}/\eta_{t+1,i}}+\frac{\eta_{t,i}-\eta_{t+1,i}}{\eta_{t,i}}.$$
+
+Now consider the first term on the right hand side above and note that
+
+w ηt,i/ηt+1,i t+1,i = wt,i exp ηt,irt+1,i − η 2 t,i(rt+1,i − rˆt+1,i) 2by definition; see Line 10 = wt,i exp(ηt,irˆt+1,i) exp ηt,i(rt+1,i − rˆt+1,i) − η 2 t,i(rt+1,i − rˆt+1,i) 2adding and subtracting ηt,irˆt+1,i ≤ wt,i exp(ηt,irˆt+1,i) (1 + ηt,i(rt+1,i − rˆt+1,i)) by (1) of Lemma 4 = wt,iηt,i exp(ηt,irˆt+1,i)rt+1,i + wt,i exp(ηt,irˆt+1,i) (1 − ηt,irˆt+1,i) | {z } ≤exp(−ηt,irˆt+1,i) (1 + x ��� e xfor all real x) ≤ wt,iηt,i exp(ηt,irˆt+1,i) rt+1,i + wt,i.
+$$\leq\underbrace{w_{t,i}\eta_{t,i}\exp(\eta_{t,i}{\hat{r}}_{t+1,i})}_{\propto p_{t+1,i}}r_{t+1,i}+w_{t,i}.$$
+As the brace above shows, the first part of the first expression on the right hand side is proportional to pt+1,i by construction (see Line 3 in Alg. 3). Recalling that rt+1,i = hpt+1, `t+1i − `t+1,i, we have by dividing and multiplying by the normalization constant,
+
+$$\sum_{i\in[K]}w_{t,i}\eta_{t,i}\exp(\eta_{t,i}\hat{r}_{t+1,i})r_{t+1,i}=\left(\sum_{i\in[K]}w_{t,i}\eta_{t,i}\exp(\eta_{t,i}\hat{r}_{t+1,i})\right)\sum_{i\in[K]}p_{t+1,i}r_{t+1,i}=0,$$
+$$w_{t,i}=W_{t}.$$
+
+since Pi∈[K]
+pt+1,irt+1,i = 0. This shows that Pi∈[K] w
+at $\sum_{i\in[K]}w_{t+1,i}^{\eta_{t,i}/\eta_{t+1,i}}$. 
+t+1,i ≤Pi∈[K] wt,i = Wt.
+
+Putting it all together and applying (3) from Lemma 4 to bound ηt,i−ηt+1,i ηt,i, we obtain for the sum of potentials for t ∈ [T]:
+
+$$W_{t+1}\leq W_{t}+\sum_{i\in[K]}\log(\eta_{t,i}/\eta_{t+1,i}).$$
+
+A subtle issue is that for t = 0, we have η0,i =plog(K)/2 for all i ∈ [n], which means that we cannot apply
+(1) of Lemma 4. So, we have to bound the change in potentials between W1 and W0. Fortunately, since this only occurs at the start, we can use the rough upper bound exp(x − x 2) = exp(x(1 − x)) ≤ exp(1/4) ≤ 1.285, which holds for all x ∈ R, to obtain for t = 0
+
+$$w_{t+1,i}^{\eta_{t,i}/\eta_{t+1,i}}\leq w_{t,i}\exp(\eta_{t,i}\hat{r}_{t+1,i})\exp(1/4)$$
+$=w_{t,i}\hat{r}_{t+1,i}+\eta_{t,i}\hat{r}_{t+1,i})\exp(\eta_{t,i}\hat{r}_{t+1,i})\exp(1/4)$  $\leq w_{t,i}(\exp(-\eta_{t,i}\hat{r}_{t+1,i})+\eta_{t,i}\hat{r}_{t+1,i})\exp(\eta_{t,i}\hat{r}_{t+1,i})\exp(1/4)$  $=\exp(1/4)w_{t,i}+\hat{r}_{t+1,i}\underbrace{\exp(1/4)w_{t,i}\eta_{t,i}\exp(\eta_{t,i}\hat{r}_{t+1,i})}_{\propto p_{t+1,i}},$
+where we used 1 − x ≤ exp(−x). Summing the last expression we obtained across all i ∈ [K], we have for t = 0
+
+$$\sum_{i\in[K]}w_{t+1,i}^{\eta_{t,i}/\eta_{t+1,i}}\leq\sum_{i\in[K]}\exp(1/4)w_{t,i},$$
+
+where we used the fact that Pi∈[K]
+rˆt+1,iwt,iηt,i exp(ηt,irˆt+1,i) = 0 by definition of our predictions. Putting it all together, we obtain W1 ≤ exp(1/4)W0 = exp(1/4)K given that W0 = K.
+
+We can now unroll the recursion in light of the above to obtain
+
+ ### lrision in light of the above to obtain  $ \begin{array}{l}W_T\leq K\exp(1/4)+\sum_{t\in[T]}\sum_{i\in[K]}\log(\eta_{t,i}/\eta_{t+1,i})\\ \\ =K\exp(1/4)+\sum_{i\in[K]}\sum_{t\in[T]}\log(\eta_{t,i}/\eta_{t+1,i})\\ \\ =K\exp(1/4)+\sum_{i\in[K]}\log\left(\prod_{t+1\in[T]}\eta_{t,i}/\eta_{t+1,i}\right)\\ \\ =K\exp(1/4)+\sum_{i\in[K]}\log(\eta_{0,i}/\eta_{T,i})\\ \\ \leq K\left(\exp(1/4)+\log\left(\max_{i\in[K]}\sqrt{C_{T,i}}\right)\right)\\ \\ \leq K\left(\exp(1/4)+\log(4T)/2\right).\end{array}$
+Now, we establish a lower bound for Wt in terms of the regret with respect to any expert i ∈ [K]. Taking the logarithm and using the fact that the potentials are always non-negative, we can show via a straightforward induction (as in (Gaillard et al., 2014)) that
+
+$$\log(W_{T})\geq\log(w_{T,i})\geq\eta_{T,i}\sum_{t\in[T]}(r_{t,i}-\eta_{t-1,i}(r_{t,i}-\hat{r}_{t,i})^{2}).$$
+
+Rearranging, and using the upper bound on WT from above, we obtain
+
+$$\sum_{t\in[T]}r_{t,i}\leq\eta_{T,i}^{-1}\log\left(K(1+\log(\max_{t\in[R]}\sqrt{1+C_{T,i}})\right)+\sum_{t\in[T]}\eta_{t-1,i}(r_{t,i}-\hat{r}_{t,i})^{2}.\tag{2}$$
+
+For the first term in (2), consider the definition of η*T ,i* and note that η*T ,i* ≥ min{1/3, ηT −1,i,plog(K)/(C*T ,i*)} since rˆT +1,i ≤ 1. Now to lower bound η*T ,i*, consider the claim that ηt,i ≥ min{1/3,plog(K)/(C*T ,i*)}. Note that this claim holds trivially for the base cases where t = 0 and t = 1 since the learning rates are initialized to 1 and our optimistic predictions can be at most 1. By induction, we see that if this claim holds at time step t, we have for time step t + 1
+
+$$\eta_{t+1,i}\geq\min\{1/3,\eta_{t,i},\sqrt{\log(K)/(C_{t+1,i})}\}\geq\min\{1/3,\eta_{t,i},\sqrt{\log(K)/(C_{T,i})}\}$$ $$=\min\{\eta_{t,i},\min\{1/3,\sqrt{\log(K)/(C_{T,i})}\}\}$$ $$\geq\min\left\{\min\{1/3,\sqrt{\log(K)/(C_{T,i})}\},\min\{1/3,\sqrt{\log(K)/(C_{T,i})}\}\right\}$$ $$=\min\{1/3,\sqrt{\log(K)/(C_{T,i})}\}.$$
+
+Hence, we obtain η*T ,i* ≥ min{1/3, C*T ,i*}, and this implies that (by the same reasoning as in (Gaillard et al.,
+2014)) that
+
+$$\eta_{T,i}^{-1}\log\left(K(1+\log(\operatorname*{max}_{i\in[K]}{\sqrt{C_{T,i}}})\right)\leq\mathcal{O}\left(({\sqrt{\log K}}+\log\log T){\sqrt{C_{T,i}}}+\log K\right).$$
+
+Now to bound the second term in (2),Pt∈[T]
+ηt−1,i(rt,i − rˆt,i)
+2, we deviate from the analysis in (Wei et al.,
+2017) in order to show that the improved learning schedule without the dampening term in the denominator suffices. To this end, we first upper bound ηt−1,i as follows
+
+$$\begin{aligned} \eta_{t-1,i} &\leq \min\left\{\eta_{0,i},\frac{2}{3(1+\hat{r}_{t,i})},\sqrt{\frac{\log(K)}{C_{t-1,i}}}\right\}\\ &\leq \min\left\{\eta_{0,i},\sqrt{\frac{\log(K)}{C_{t-1,i}}}\right\}\\ &=\min\left\{\eta_{0,i},\eta_{0,i}\sqrt{\frac{2}{C_{t-1,i}}}\right\}\\ \end{aligned}$$  - $\hat{r}_{t,i}$ is the $i$th order of $\hat{r}_{t,i}$. 
+where first inequality follows from the fact that the learning rates are monotonically decreasing, the second inequality from the definition of min, the last equality by definition η0,i =plog(K)/2.
+
+By the fact that the minimum of two positive numbers is less than its harmonic mean4, we have
+
+$$\eta_{t-1,i}\leq\frac{2\sqrt{2}\eta_{0,i}}{\sqrt{2}+\sqrt{C_{t-1,i}}},$$
+
+and so
+
+$$(r_{t,i}-\hat{r}_{t,i})^{2}\eta_{t-1,i}\leq c_{t,i}\frac{2\sqrt{2}\eta_{0,i}}{\sqrt{2}+\sqrt{C_{t-1,i}}}$$ $$=8\sqrt{2}\eta_{0,i}\frac{(c_{t,i}/4)}{\sqrt{2}+2\sqrt{C_{t-1,i}/4}}$$ $$\leq4\sqrt{2}\eta_{0,i}\frac{(c_{t,i}/4)}{\sqrt{1/2+C_{t-1,i}/4}},$$
+
+where we used the subadditivity of the square root function in the last step.
+
+Summing over all t ∈ [T] and applying Lemma 14 of (Gaillard et al., 2014) on the scaled variables ct,i/4 ∈ [0, 1],
+we obtain
+
+$$\sum_{t\in[T]}\eta_{t-1,i}(r_{t,i}-{\hat{r}}_{t,i})^{2}\leq4{\sqrt{2}}\eta_{0,i}\sum_{t\in[T]}{\sqrt{C_{T,i}}}$$ $$=4{\sqrt{C_{T,i}\log K}},$$
+$$\square$$
+
+where in the last equality we used the definition of ηi,0 and C*T ,i* =Pt∈[T]
+(rt,i − rˆt,i)
+2 as before, and this completes the proof.
+
+## A.2 Adaptive Regret
+
+We now turn to establishing adaptive regret bounds via the sleeping experts reduction as in (Wei et al., 2017; Luo & Schapire, 2015) using the reduction of (Gaillard et al., 2014). The overarching goal is to establish an adaptive bound for the regret of *every* time interval [t1, t2], t1, t2 ∈ [T], which is a generalization of the static regret which corresponds to the regret over the interval [1, T]. To do so, in the setting of n experts as in the main document, the main idea is to run the base algorithm (Alg. 3) on K = nT *sleeping* experts instead5.
+
+These experts will be indexed by (*t, i*) with t ∈ [T] and i ∈ [n]. Moreover, at time step t, each expert (*s, i*) is 4min{*a, b*} = min{a−1, b−1}−1 ≤ (
+1 2
+(a−1 + b−1))−1 = 2/(1/a + 1/b)
+5Note that this notion of sleeping experts is the same as the one we used for dealing with constructing a distribution over only the unlabeled data points remaining.
+
+defined to be awake if s ≤ *t, i* ∈ [n] and It,i = 1 (the point has not yet been sampled, see Sec. 2), and the remaining experts will be considered sleeping. This will generate a probability distribution p¯t,(s,i) over the awake experts. Using this distribution, at round t we play
+
+$$p_{t,i}={\mathcal{I}}_{t,i}\sum_{s\in[t]}{\bar{p}}_{t,(s,i)}/Z_{t},$$
+where $Z_t=\sum_{j\in[K]}\mathcal{I}_{t,j}\sum_{s'\in[t]}\bar{P}_{t,(s',j)}$. 
+The main idea is to construct losses to give to the base algorithm so that that at any point t ∈ [T], each expert
+(*s, i*) suffers the interval regret from s to t (which is defined to be 0 if *s > t*), i.e., Ptτ=1 rτ,(s,i) =Ptτ=s rτ,i.
+
+To do so, we build on the reduction of (Wei et al., 2017) to keep track of both the sleeping experts from the sense of achieving adaptive regret and also the traditional sleeping experts regret with respect to only those points that are not yet labeled (as in Sec. 2). The idea is to apply the base algorithm (Alg. 3) with the modified loss vectors ¯`t,(s,i)for expert (*s, i*) as the original loss if the expert is awake, i.e., ¯`t,(s,i) = `t,i if s ≤ t (original reduction in (Wei et al., 2017)) and It,i = 1 (the point has not yet been sampled), and
+¯`t,(s,i) = hpt,i, `ti otherwise. The prediction vector is defined similarly: r¯t,(s,i) = rˆt,i if s ≤ t, and 0 otherwise.
+
+Note that this construction implies that the regret of the base algorithm with respect to the modified losses and predictions, i.e., r¯τ,(s,i) = hp¯τ,(s,i),
+¯`τ,(s,i)i is equivalent to rτ,i for rounds *τ > s* where the expert is awake, and 0 otherwise. Thus,
+
+$$\sum_{\tau\in[t]}{\bar{r}}_{\tau,(s,i)}=\sum_{\tau=s}^{t}r_{\tau,i},$$
+
+which means that the regret of expert (*s, i*) with respect to the base algorithm is precisely regret of the interval [*s, t*]. Applying Lemma 5 to this reduction above (with K = nT) immediately recovers the adaptive regret guarantee of Optimisic Adapt-ML-Prod.
+
+Lemma 6 (Adaptive Regret of Base AdaProd+). For any t1 ≤ t2 and i ∈ [n], invoking Alg. 3 with the sleeping experts reduction described above ensures that
+
+$$\sum_{t=t_{1}}^{t_{2}}r_{t,i}\leq\hat{\mathcal{O}}\left(\log(K)+\sqrt{C_{t_{2},(t_{1},i)}\log(K)}\right),$$
+
+where Ct2,(t1,i) =Pt2 t=t1
+(rt,i − rˆt,i)
+2 and Oˆ *suppresses* log T *factors.*
+
+## A.3 Adaprod+ **And Proof Of Lemma** 1
+
+To put it all together, we relax to requirement of having to update and keep track of K = NT experts and having to know T. To do so, observe that log(K) ≤ log(nT) ≤ 2 log(n) since T ≤ n/ mint∈[T] bt ≤ n, where bt ≥ 1 is the number of new points to label at active learning iteration t. This removes the requirement of having to know T or the future batch sizes beforehand, meaning that we can set the numerator of ηt,(s,i) to be p2 log(n) instead of plog(K) (as in 2 in Sec. 3). Next, observe that in the sleeping experts reduction above, we have
+
+$$p_{t,i}={\mathcal{I}}_{t,i}\sum_{s\in[t]}{\bar{p}}_{t,(s,i)}/Z_{t},$$
+
+where Zt =Pj∈[K]
+It,j Ps 0∈[t]
+p¯t,(s 0,j). But for s ≤ t and j ∈ [n] satisfying It,j = 1, by definition of p¯t,(s,j)
+and the fact that expert (*s, j*) is awake, we have p¯t,(s,j) ∝ ηt−1,(s,j)wt−1,(s,j) exp(ηt−1,(s,j)rˆt,j ), and so the normalization constant cancels from the numerator (from p¯t,(s,j)) and the denominator (from the p¯t,(s 0,j)in Zt =Pj∈[K]
+It,j Ps 0∈[t]
+p¯t,(s 0,j)), leaving us with
+
+$$p_{t,i}=\sum_{s\in[t]}{\frac{\eta_{t-1,(s^{\prime},j)}w_{t-1,(s^{\prime},j)}\exp(\eta_{t-1,(s^{\prime},j)}\hat{r}_{t,j})}{\gamma_{t}}},$$
+
+where γt =Pj∈[K]
+Ps 0∈[t]
+ηt−1,(s 0,j)wt−1,(s 0,j) exp(ηt−1,(s 0,j)rˆt,j ). Note that this corresponds precisely to the probability distribution played by AdaProd+. Further, since AdaProd+ does not explicitly keep track of the experts that are asleep, and only updates the potentials Wt,(s,i) of those experts that are awake, AdaProd+ mimics the updates of the reduction described above6involving passing of the modified losses to the base algorithm. Thus, we can conclude that AdaProd+ leads to the same updates and generated probability distributions as the base algorithm for adaptive regret. This discussion immediately leads to the following lemma for the adaptive regret of our algorithm, very similar to the one established above except for log n replacing log T terms.
+
+Lemma 1 (Adaptive Regret of AdaProd+). For any t1 ≤ t2 and i ∈ [n], Alg. 2 *ensures that*
+
+$$\sum_{t=t_{1}}^{t_{2}}r_{t,i}\leq\mathcal{O}\left(\log n+\log\log n+(\sqrt{\log n}+\log\log n)\sqrt{C_{t_{2,}(t_{1},i)}}\right),$$
+
+where Ct2,(t1,i) =Pt2 t=t1
+(rt,i − rˆt,i)
+2 and rt,i = (h`t, pti − `t,i)It,i is the instantaneous regret of i ∈ [n] *at time* t and rˆt,i = (h ˆ`t, pti − ˆ`t,i)It,i *is the predicted instantenous regret as a function of the optimistic loss vector* ˆ`t *prediction.*
+
+## A.4 Proof Of Theorem 2
+
+Theorem 2 (Dynamic Regret). AdaProd+ *takes at most* O˜(tnt)
+7*time for the* t th update and for batch size b = 1 for all t ∈ [T], guarantees that over T *steps,*
+
+$$\operatorname*{max}_{(i_{t})_{t\in[T]}}\mathbb{E}\left[\mathcal{R}(i_{1:T})\right]\leq\hat{\mathcal{O}}\left(\sqrt[3]{\mathbb{E}\left[\mathcal{V}_{T}\right]D_{T}T\log n}+\sqrt{D_{T}T\log n}\right),$$
+
+where Oˆ(·) *suppresses* log T factors.
+
+Proof. Fix (i
+∗
+t
+)t∈[T] be an arbitrary competitor sequence. First observe that the expected regret over all the randomness as defined Sec. 2 can be written as
+
+$$\mathbb{E}\left[\mathcal{R}(i_{1:T}^*)\right]=\mathbb{E}\,\left[\sum_{t\in[T]}\mathbb{E}\,\left[r_{t,i_t^*}\right]\right]$$ $$=\sum_{\mathcal{S}_{1:T-1},\xi_{0:T-1}}\left[\sum_{t\in[T]}r_{t,i_t^*}\right]$$
+
+which follows by linearity of expectation and the fact that pt is independent of ξt−1 and the noises ξ1:T are independent random variables.
+
+Similar to the approach of (Wei et al., 2017; Besbes et al., 2014), consider partitioning the time horizon T
+into N = d*T /B*e contiguous time blocks T1*, . . . ,* TN of length B, with the possible exception of TN which has length at most B. For any time block T , let iT denote the best sample with respect to the expected regret, i.e.,
+
+$$i_{\mathcal{T}}=\operatorname*{argmax}_{i\in[n]}\mathbb{E}\left[\sum_{t\in\mathcal{T}}r_{t,i}\right],$$
+
+where the expectation is with respect to all sources of randomness. Continuing from above, Note that the expected dynamic regret in Sec. 2 can be decomposed as follows:
+
+$$\mathbb{E}\left[\mathcal{R}(i_{1:T}^{*})\right]=\mathbb{E}\left[\sum_{b=1}^{N}\sum_{t\in\mathcal{T}_{b}}r_{t,i_{t}^{*}}-r_{t,i_{\mathcal{T}_{b}}}\right]+\mathbb{E}\left[\sum_{b=1}^{N}\sum_{t\in\mathcal{T}_{b}}r_{t,\mathcal{T}_{b}}\right].$$
+
+6The only minor change is in the constant in the learning rate schedule of AdaProd+ which has a p2 log(n) term instead of plog(nT) ≤p2 log(n). This only affects the regret bounds by at most a factor of √2, and the reduction remains valid - it would be analogous to running Alg. 3 on a set of n 2 ≥ nT experts instead.
+
+7We use O˜(·) to suppress log T and log n factors.
+
+$$=\underbrace{\sum_{b=1}^{N}\sum_{t\in\mathcal{T}_{b}}\mathbb{E}\,\left[r_{t,i_{t}^{*}}-r_{t,i_{\mathcal{T}_{b}}}\right]}_{(\mathrm{A})}+\underbrace{\sum_{b=1}^{N}\mathbb{E}\,\left[\sum_{t\in\mathcal{T}_{b}}r_{t,i_{\mathcal{T}_{b}}}\right]}_{(B)},$$
+
+where the last equality follows by linearity of expectation.
+
+To deal with the first term, consider an arbitrary time block T and define the drift in expected regret
+
+$${\mathcal{D}}_{{\mathcal{T}}}=\sum_{t\in[{\mathcal{T}}]}\|\mathbb{E}\left[r_{t}\right]-\mathbb{E}\left[r_{t-1}\right]\|_{\infty}\,.$$
+
+For each t ∈ T and i
+∗
+t ∈ [n] we know that there must exist t0 ∈ T such that E [rt0,iT
+] ≥ E [rt0,i∗
+t
+]. To see this, note that the negation of this statement would imply Pt∈T E [rt,iT
+] ≤Pt∈T E [rt,i∗
+t
+] which contradicts the optimality of iT . For any t ∈ T , we have
+
+$\mathbb{E}\left[r_{t,i_{t}^{*}}\right]\leq\mathbb{E}\left[r_{t_{0},i_{t}^{*}}\right]+\mathcal{D}_{\mathcal{T}}\leq\mathbb{E}\left[r_{t_{0},i_{\tau}}\right]+\mathcal{D}_{\mathcal{T}}\leq\mathbb{E}\left[r_{t,i_{\tau}}\right]+2\mathcal{D}_{\mathcal{T}}$,
+where the first and third inequalities are by the definition of DT and the second by the argument above over
+t0. This implies that
+$$\sum_{t\in{\mathcal{T}}}\mathbb{E}\,\left[r_{t,i_{t}^{*}}-r_{t,i\tau_{b}}\right]\leq2B{\mathcal{D}}_{\mathcal{T}}.$$
+Summing over N blocks, we obtain that
+(A) ≤ 2BDT = 2(*T /N*)DT ,
+where DT =Pt∈[T]
+kE [rt] − E [rt−1]k∞.
+
+For the second term, we apply the adaptive regret bound of Lemma 1 to each block Tb ranging from time t 1 b to t 2 b to obtain
+
+$$\mathbb{E}\left[\sum_{t\in\mathcal{T}_{b}}r_{t,i_{\mathcal{T}_{b}}}\right]\leq\hat{O}\left(\mathbb{E}\left[\sqrt{C_{t_{b}^{2},\left(t_{b}^{1},i_{\mathcal{T}_{b}}\right)}}\right]+\log n\right).$$
+
+Summing over all N blocks we have
+
+(B) = X N b=1 E "X t∈Tb rt,iTb # ≤ Oˆ  E "X N b=1 qCt 2 b ,(t 1 b ,iTb )log n # + N log n ! ≤ Oˆ  E  b=1 s X t∈[Tb] krt − rˆtk 2 ∞ log n   + N log n  X N  ≤ OˆE hpNVT log n i+ N log n ,
+
+```
+where the second to last inequality follows by the definition of Ct
+                                                                   2
+                                                                   b
+                                                                    ,(t
+                                                                      1
+                                                                      b
+                                                                      ,iTb
+                                                                         ) and the last inequality is by
+Cauchy-Schwarz.
+
+```
+
+Putting both bounds together, we have that
+
+$$\mathbb{E}\left[\mathcal{R}(i_{1:T}^{*})\right]=\operatorname*{min}_{N\in[T]}\hat{\mathcal{O}}\left(\mathbb{E}\left[\sqrt{N\mathcal{V}_{T}\log n}+N\log n+(T/N)\mathcal{D}_{T}\right]\right).$$
+
+All that remains is to optimize the bound with respect to the number of epochs N. If V
+2 T ≤ TDT log n, we can pick N =p*T D/* log n to obtain a bound of Oˆ(
+√TDT log n). On the other hand, if V
+2 T > TDT log n we can let N =p3 T2D2T
+/(VT log n) to obtain the bound Oˆ(
+√3 TDT VT log n). Hence, in either case we have the upper bound
+
+upper bound $$\hat{\mathcal{O}}\left(\mathbb{E}\left[\sqrt[3]{\mathcal{V}_T\mathcal{D}_T T\log n}+\sqrt{\mathcal{D}_T T\log n}\right]\right)\leq\hat{\mathcal{O}}\left(\sqrt[3]{\mathbb{E}\left[\mathcal{V}_T\right]\mathcal{D}_T T\log n}+\sqrt{\mathcal{D}_T T\log n}\right),$$ where the inequality is by Jensen's. 
+
+## A.5 Proof Of Theorem 3
+
+Theorem 3 (Dynamic Regret). AdaProd+ with batch sampling of b points guarantees that over T *steps,*
+
+$$\operatorname*{max}_{(\mathcal{S}_{t})_{t\in[T]}:|\mathcal{S}_{t}|=b\,\forall t}\mathbb{E}\left[\mathcal{R}(\mathcal{S}_{1:T})\right]\leq\hat{\mathcal{O}}\left(b\sqrt[3]{\mathbb{E}\left[\mathcal{V}_{T}\right]\,\mathcal{D}_{T}T\log n}+b\sqrt{\mathcal{D}_{T}T\log n}\right).$$
+
+Proof. For any fixed sequence (S
+∗
+1
+, . . . , S
+∗
+T
+), we have
+
+E [R(S ∗ 1:T )] = E X T t=1 X b j=1 E ξt−1 [rt,S∗ tj ] = E X b j=1 X T t=1 E ξt−1 [rt,S∗ tj ] = X b j=1 E "X T t=1 (hpt, `t(ξt−1)i − `t,i(ξt−1))It,i# | {z } per point regret from Theorem 2 ≤ b Oˆp3 E [VT ] DT T log n +pDT T log n 
+
+$\square$
+where we used the fact that ρt = bpt and the definition of rt from Sec. 4.2.
+
+## B Implementation Details And Batch Sampling
+
+To sample b points according to a probability distribution p with Pi pi = b, we use use the DepRound algorithm (Uchiya et al., 2010) shown as Alg. 4, which takes O(n) time.
+
+Algorithm 4 DepRound Inputs: Probabilities p ∈ [0, 1]n such that Pi pi = b Output: set of indices C ⊂ [n] of size b 1: **while** ∃i ∈ [n] such that 0 < pi < 1 do 2: Pick *i, j* ∈ [n] satisfying i 6= j, 0 < pi < 1, and 0 < pj < 1 3: Set α = min(1 − pi, pj ) and β = min(pi, 1 − pj )
+4: Update pi and pj
+
+$(p_{i},p_{j})=\begin{cases}(p_{i}+\alpha,p_{j}-\alpha)&\text{with probability}\\ (p_{i}-\beta,p_{j}+\beta)&\text{with probability}\end{cases}$
+α+β
+,
+α+β
+.
+5: **end while**
+6: *C ← {*i ∈ [n] : pi = 1}
+return C
+In all of our empirical evaluations, the original probabilities generated by AdaProd+ were already less than 1/b, so the capping procedure did not get invoked. We conjecture that this may be a natural consequence of the active learning setting, where we are attempting to incrementally build up a small set of labeled data among a very large pool of unlabeled ones, i.e., b  n. This description also aligns with the relatively small batch sizes widely used in active learning literature as benchmarks (Gissin & Shalev-Shwartz, 2019; Ash et al., 2019; Ren et al., 2020; Sener & Savarese, 2017; Muthakana, 2019).
+
+The focus of our work is not on the full extension of Adapt-ML-Prod (Wei et al., 2017) to the batch setting, however, we summarize some of our ongoing and future work here for the interested reader. If we assume that the probabilities generated by AdaProd+ satisfy pt,i ≤ 1/b, which is a mild assumption in the active learning setting as evidenced by our evaluations, we establish the bound as in Sec. 4.2 for the regret defined with respect to sampling a batch of b points at each time step. In future work, we plan to relax the assumption pt,i ≤ 1/b by building on techniques from prior work, such as by exploiting the inequalities associated with the Information (KL divergence) Projection as in (Warmuth & Kuzmin, 2008) or capping the weight potential wi,t as in (Uchiya et al., 2010) as soon as weights get too large (rather than modifying the probabilities).
+
+## C Experimental Setup & Additional Evaluations
+
+In this section we (i) describe the experimental setup and detail hyper-parameters used for our experiments and (ii) provide additional evaluations and comparisons to supplement the results presented in the manuscript.
+
+The full code is included in the supplementary folder8.
+
+## C.1 Setup
+
+|                      | FashionCNN    | SVHNCNN       | Resnet18      | CNN5 (width=128)   |
+|----------------------|---------------|---------------|---------------|--------------------|
+| loss                 | cross-entropy | cross-entropy | cross-entropy | cross-entropy      |
+| optimizer            | Adam          | Adam          | SGD           | Adam               |
+| epochs               | 60            | 60            | 80            | 60                 |
+| epochs incremental   | 15            | 15            | N/A           | 15                 |
+| batch size           | 128           | 128           | 256           | 128                |
+| learning rate (lr)   | 0.001         | 0.001         | 0.1           | 0.001              |
+| lr decay             | 0.1@(50)      | 0.1@(50)      | 0.1@(30, 60)  | 0.1@(50)           |
+| lr decay incremental | 0.1@(10)      | 0.1@(10)      | N/A           | 0.1@(10)           |
+| momentum             | N/A           | N/A           | 0.9           | N/A                |
+| Nesterov             | N/A           | N/A           | No            | N/A                |
+| weight decay         | 0             | 0             | 1.0e-4        | 0                  |
+
+Table 1: We report the hyperparameters used during training the convolutional architectures listed above corresponding to our evaluations on FashionMNIST, SVHN, CIFAR10, and ImageNet. except for the ones indicated in the lower part of the table. The notation γ@(n1, n2*, . . .*) denotes the learning rate schedule where the learning rate is multiplied by the factor γ at epochs n1, n2*, . . .* (this corresponds to MultiStepLR in PyTorch).
+
+Table 1 depicts the hyperparameters used for training the network architectures used in our experiments.
+
+Given an active learning configuration (Option, nstart*, b, n*end), these parameters describe the training process for each choice of Option as follows: **Incremental** : we start the active learning process by acquiring and labeling nstart points chosen uniformly at random from the n unlabeled data points, and we train with the corresponding number of epochs and learning rate schedule listed in Table 1 under rows *epochs* and lr decay, respectively, to obtain θ1. We then proceed as in Alg. 1 to iteratively acquire b new labeled points based on the Acquire function and *incrementally train* a model starting from the model from the previous iteration, θt−1. This training is done with respect to the number of corresponding epochs and learning rate schedule shown in Table 1 under *epochs incremental* and *lr decay incremental*, respectively. **Scratch** : the only difference relative to the Incremental setting is that rather than training the model starting from θt−1, we train a model from a randomly initialized network at each active learning iteration with respect to the training parameters under *epochs* and *lr decay* in Table 1.
+
+Architectures We used the following convolutional networks on the specified data sets.
+
+1. FashionCNN (Pankajj, *2018)* (for FashionMNIST): a network with 2 convolutional layers with batch normalization and max pooling, 3 fully connected layers, and one dropout layer with p = 0.25 in (Pankajj, 2018). This architecture achieves over 93% accuracy when trained with the whole data set.
+
+2. SVHNCNN (Chen, *2020)* (for SVHN): a small scale convolutional model very similar to FashionCNN
+except there is no dropout layer.
+
+3. Resnet18 (He et al., *2016)* (for ImageNet): an 18 layer residual network with batch normalization.
+
+4. CNN5 (Nakkiran et al., *2019)* (for CIFAR10): a 5-layer convolutional neural network with 4 convolutional layers with batch normalization. We used the width=128 setting in the context of (Nakkiran et al., 2019).
+
+Settings for experiments in Sec. 5 Prior to presenting additional results and evaluations in the next subsections, we specify the experiment configurations used for the experiments shown in the main 8Our codebase builds on the publicly available codebase of (Liebenwein, 2021; Liebenwein et al., 2019; Baykal et al., 2018).
+
+![25_image_0.png](25_image_0.png) 
+Uniform
+Figure 6: Results for the data-starved configuration (Scratch, 5k, 5k, 45k) on ImageNet (first row) and
+(Scratch, 50, 10, 500) on FashionMNIST (second row). Shown from left to right are the results with respect to test accuracy, top-5 test accuracy, and test loss. Shaded region corresponds to values within one standard deviation of the mean.
+document (Sec. 5). For the corresponding experiments in Fig. 2, we evaluated on the configuration
+(Scratch, 10k, 20k, 110k) for ImageNet, (Scratch, 500, 200, 4000) for SVHN, (Scratch, 3k, 1k, 15k) for CIFAR10, and (Scratch, 100, 300, 3000) for FashionMNIST. For the evaluations in Fig. 4, we used
+(Scratch, 128, 96, 200) and (Scratch, 128, 64, 2000) for FashionMNIST and SVHN, respectively. The models were trained with standard data normalization with respect to the mean and standard deviation of the entire training set. For ImageNet, we used random cropping to 224 × 224 and random horizontal flips for data augmentation; for the remaining data sets, we used random cropping to 32 × 32 (28 × 28 for FashionMNIST) with 4 pixels of padding and random horizontal flips.
+
+All presented results were averaged over 10 trials with the exception of those for ImageNet9, where we averaged over 3 trials due to the observed low variance in our results. We used the uncertainty loss metric as defined in Sec. 2 for all of the experiments presented in this work - with the exception of results related to boosting prior approaches (Fig. 4). The initial set of points and the sequence of random network initializations
+(one per sample size for the Scratch option) were fixed across all algorithms to ensure fairness.
+
+## C.2 Setting For Experiments In Sec. 5.5
+
+In this subsection, we describe the setting for the evaluations in Sec. 5.5, where we compared the performance of AdaProd+ to modern algorithms for learning with prediction advice. Since our approach is intended to compete with time-varying competitors (see Sec. A), we compare it to existing methods that ensure low regret with respect to time-varying competitors (via adaptive regret). In particular, we compare our approach to the following algorithms:
+1. **Optimistic AMLProd** (Wei et al., 2017): we implement the (stronger) variant of Optimistic Adapt-MLProd that ensures dynamic regret (outlined at the end of Sec. 3.3 in (Wei et al., 2017)). This algorithm uses the sleeping experts reduction of (Gaillard et al., 2014) and consequently, requires initially creating n˜ = nT sleeping experts and updating them with similar updates as in our algorithm (except the cost of the t th update is O˜(nT) rather than O˜(Ntt) as in ours). Besides the computational costs, we emphasize that the only true functional difference between our algorithm and Optimistic AMLProd lies in the
+
+9We were not able to run Coreset or BatchBALD on ImageNet due to resource constraints and the high computation requirements of these algorithms.
+thresholding of the learning rates (Line 10 in Alg. 2). In our approach, we impose the upper bound min{ηt−1,i, 2/(3(1 + rˆt+1,i))} for ηt,i for any t ∈ [T], whereas (Wei et al., 2017) imposes the (smaller)
+bound of 1/4.
+
+2. **AdaNormalHedge(.TV)** (Luo & Schapire, 2015): we implement the time-varying version of AdaNormalHedge, AdaNormalHedge.TV as described in Sec. 5.1 of (Luo & Schapire, 2015). The only slight modification we make in our setting where we already have a sleeping experts problem is to incorporate the indicator It,i in our predictions (as suggested by (Luo & Schapire, 2015) in their sleeping experts variant). In other words, we predict10 pt,i ∝ It,i Ptτ=1 1 τ 2 w(R[τ,t−1],i, C[τ,t−1]) rather than the original pt,i ∝Ptτ=1 1 τ 2 w(R[τ,t−1],i, C[τ,t−1]), where R[t1,t1],i =Pt2 t=t1 rt,i and C[t1,t1],i =Pt2 t=t1 |rt,i| (note that the definition of C is different than ours).
+
+3. **Squint(.TV)** (Koolen & Van Erven, 2015): Squint is a parameter-free algorithm like AdaNormalHedge in that it can also be extended to priors over an initially unknown number of experts. Hence, we use the same idea as in AdaNormalHedge.TV (also see (Luo, 2017)) and apply the extension of the Squint algorithm for adaptive regret.
+
+We used the (Scratch, 500, 200, 400) and (Scratch, 4000, 1000, 2000) configurations for the evaluations on the SVHN and CIFAR10 datasets, respectively.
+
+## C.3 Results On Data-Starved Settings
+
+Figure 6 shows the results of our additional evaluations on ImageNet and FashionMNIST in the *data-starved* setting where we begin with a very small (relatively) set of data points and can only query the labels of a small set of points at each time step. For both data sets, our approach outperforms competing ones in the various metrics considered - yielding up to 4% increase in test accuracy compared to the second-best performing method.
+
+## C.4 Shifting Architectures
+
+In this section, we consider the performance on FashionMNIST and SVHN when we change the network architectures from those used in the main body of the paper (Sec. 5). In particular, we conduct experiments on the *FashionNet* and *SVHNNet* architectures11, convolutional neural networks that were used for benchmark evaluations in recent active learning work (Ash et al., 2019; Ash, 2021). Our goal is to evaluate whether the performance of our algorithm degrades significantly when we vary the model we use for active learning.
+
+Fig. 7 depicts the results of our evaluations using the same training hyperparameters as FashionCNN for FashionNet, and similarly, those for SVHNCNN for SVHNNet (see Table 1). For both architectures, our algorithm uniformly outperforms the competing approaches in virtually all sample sizes and scenarios; our approach achieves up to 5% and 2% higher test accuracy than the second best-performing method on FashionMNIST and SVHN, respectively. The sole exception is the SVHN test loss, where we come second to Coreset - which performs surprisingly well on the test loss despite having uniformly lower test accuracy than Ours on SVHN (top right, Fig. 7). Interestingly, the relative performance of our algorithm is even better on the alternate architectures than on the models used in the main body (compare Fig. 7to Fig. 2 of Sec. 5), where we performed only modestly better than competing approaches in comparison.
+
+## C.5 Robustness Evaluations On Shifted Architecture
+
+Having shown that the resiliency of our approach for both data sets for the configuration shown in Fig. 7, we next investigate whether we can also remain robust to varying active learning configurations on alternate architectures. To this end, we fix the FashionMNIST dataset, the FashionNet architecture, and the Scratch 10We also implemented and evaluated the method with uniform prior over time intervals, i.e., pt,i ∝
+It,i Ptτ=1 w(R[τ,t−1],i, C[τ,t−1]) (without the prior 1 τ2
+), but found that it performed worse than with the prior in practice. The same statement holds for the Squint algorithm.
+
+11Publicly available implementation and details of the architectures (Ash et al., 2019; Ash, 2021): https://github.com/
+JordanAsh/badge/blob/master/model.py .
+
+![27_image_0.png](27_image_0.png)
+
+Figure 7: Evaluations on the FashionNet and SVHNNet (Ash et al., 2019; Ash, 2021) architectures, which are different convolutional networks than those used in the main body of the paper (Sec. 5). Despite this architecture shift, our approach remains the overall top-performer on the evaluated data sets, even exceeding the relative performance of our approach on the previously used architectures.
+option and consider varying the batch sizes and the initial and final number of labeled points. Most distinctly, we evaluated sample (active learning batch) sizes of 16, 96, and 224 points for varying sample budgets.
+
+We present the results of our evaluations in Fig. 8, where each row corresponds to a differing configuration.
+
+For the first row of results corresponding to a batch size of 224, we see that we significantly (i.e., up to 3.5%
+increased test accuracy) outperform all compared methods for all sample sizes with respect to both test accuracy and loss. The same can be said for the second row of results corresponding to a batch size of 96, where we observe consistent improvements over prior work. For the smallest batch size 16 (last row of Fig. 8)
+and sampling budget (600), Ours still bests the compared methods, but the relative improvement is more modest (up to ≈ 1.5% improvement in test accuracy) than it was for larger batch sizes. We conjecture that this is due to the fact that the sampling budget (600) is significantly lower than in the first two scenarios
+(up to 6000); in this data-starved regime, even a small set of uniformly sampled points from FashionMNIST
+is likely to help training since the points in the small set of selected points will most likely be sufficiently distinct from one another.
+
+## D Discussion Of Limitations & Future Work
+
+In this paper we introduced AdaProd+, an optimistic algorithm for prediction with expert advice that was tailored to the active learning. Our comparisons showed that AdaProd+ fares better than Greedy and competing algorithms for learning with prediction advice. Nevertheless, from an online learning lens, AdaProd+ can itself be improved so that it can be more widely applicable to active learning. For one, we currently require the losses to be bounded to the interval [0, 1]. This can be achieved by scaling the losses by their upper bound `max (as we did for the Entropy metric), however, this quantity `max may not be
+
+![28_image_0.png](28_image_0.png)
+
+FashionMNIST dataset.
+available beforehand for all loss metrics. Ideally, we would want a scale-free algorithm that works with any loss to maximize the applicability of our approach.
+
+In a similar vein, in future work we plan to extend the applicability of our framework to clustering-based active-learning, e.g., Coreset (Sener & Savarese, 2017) and Badge (Ash et al., 2019), where it is more difficult to quantify what the loss should be for a given clustering. One idea could be to define the loss of an unlabeled point to be proportional to its distance - with respect to some metric - to the center of the cluster that the point belongs to (e.g., ≈ 0 loss for points near a center). However, it is not clear that the points near the cluster center should be prioritized over others as we may want to prioritize cluster outliers too. It is also not clear what the distance metric should be, as the Euclidean distance in the clustering space may be ill-suited. In future work, we would like to explore these avenues and formulate losses capable of appropriately reflecting each point's importance with respect to a given clustering. In light of the discussion above, we hope that this work can contribute to the development of better active learning algorithms that build on AdaProd+ and the techniques presented here.

3dSZUYjPwN/3dSZUYjPwN_meta.json

@@ -0,0 +1,25 @@
+{
+    "languages": null,
+    "filetype": "pdf",
+    "toc": [],
+    "pages": 30,
+    "ocr_stats": {
+        "ocr_pages": 0,
+        "ocr_failed": 0,
+        "ocr_success": 0,
+        "ocr_engine": "none"
+    },
+    "block_stats": {
+        "header_footer": 30,
+        "code": 1,
+        "table": 1,
+        "equations": {
+            "successful_ocr": 69,
+            "unsuccessful_ocr": 4,
+            "equations": 73
+        }
+    },
+    "postprocess_stats": {
+        "edit": {}
+    }
+}