Active Learning of Classiﬁers with Label and Seed Queries
Abstract
We study exact active learning of binary and multiclass classiﬁers with margin.
Given an n -point set X ⇢ R m , we want to learn an unknown classiﬁer on X whose classes have ﬁnite strong convex hull margin , a new notion extending the
SVM margin.
In the standard active learning setting, where only label queries are allowed, learning a classiﬁer with strong convex hull margin  requires in the worst case ⌦  1 + 1   m  1 2 queries.
On the other hand, using the more powerful seed queries (a variant of equivalence queries), the target classiﬁer could be learned in O ( m log n ) queries via Littlestone’s Halving algorithm; however, Halving is computationally inefﬁcient.
In this work we show that, by carefully combining the two types of queries, a binary classiﬁer can be learned in time poly( n + m ) using only O ( m 2 log n ) label queries and O  m log m   seed queries; the result extends to k -class classiﬁers at the price of a k !
k 2 multiplicative overhead.
Similar results hold when the input points have bounded bit complexity, or when only one class has strong convex hull margin against the rest.
We complement the upper bounds by showing that in the worst case any algorithm needs ⌦  km log 1   seed and label queries to learn a k -class classiﬁer with strong convex hull margin
Introduction
This work investigates efﬁcient algorithms for exact active learning of binary and multiclass classiﬁers in the transductive setting.
Given a set X of n points in R m , our goal is to learn a function h : X ! [ k ] belonging to some class H .
In the classic active learning framework, h identiﬁes a subset of X , and the algorithm learns h via queries LABEL ( x ) that return h ( x ) for any given x 2 X .
In that case, it is well-known that h can be learned with O (log n ) LABEL queries if the star number of H is ﬁnite [Hanneke and Yang, 2015].
Unfortunately, even simple families such as linear classiﬁers have unbounded star number, in which case ⌦ ( n ) LABEL queries are needed in the worst case.
To bypass this lower bound, it has become increasingly common to introduce enriched queries , that reveal additional information on h and are plausible in practice.
One notable example is that of comparison queries for linear separators in R m which, given any pair of points x, y 2 X , reveal which one is closer to the decision boundary.
As proven by Kane et al.
[2017], under some margin assumptions the combination of LABEL and comparisons yields exponential savings, allowing one to learn linear separators with only O (log n ) queries.
In this work we combine LABEL queries with seed queries .
For any U ⇢ X and any i 2 [ k ] , a query SEED ( U, i ) returns an abitrary point x in U \ C i , where C i =
h  1 ( i ) , or NIL if no such x exists.
SEED queries are natural in certain settings like crowdsourcing—e.g., ﬁnding the image of a car, see also Beygelzimer et al.
[2016]—and have been used implicitly or explicitly in several works [Hanneke, 2009, Balcan and Hanneke, 2012, Attenberg and Provost, 2010, Tong and Chang, 2001, Doyle et al., 2011, Bressan et al., 2021b].
It is not hard to see that, using SEED alone, one can implement Littlestone’s Halving algorithm and learn any h 2 H with O (log |H| ) queries 1 .
For instance, linear separators in R m can be learned with O ( m log n ) SEED queries.
The catch is that, save for special cases, it is not known how to run the Halving algorithm in polynomial time.
Therefore, using SEED to obtain a computationally efﬁcient active learning algorithm is less trivial than it seems at ﬁrst glance.
The goal of this work is understanding whether one can actively learn binary and multiclass classiﬁers efﬁciently by using LABEL and SEED queries together.
In line with Kane et al.
[2017] and other previous works, we make assumptions on H .
Our main assumption is that every class C i has strong convex hull margin  > 0 .
This means that, for any j 6 = i , C i and C j are linearly separable with a margin that is at least  2 times the diameter of C i .
Moreover, it is sufﬁcient that this hold under some pseudometric d i , unknown to the learner, that is homogeneous and invariant under translation (i.e., induced by a seminorm).
This gives to every class its own personalized notion of distance that can be sensitive to the “scale” of the class.
This assumption strictly generalizes the classical SVM margin; and, when suitably generalized, it captures stability properties of center-based clusterings Awasthi et al.
[2012], Bilu and Linial [2012].
Using LABEL alone, Bressan et al.
[2021a] showed that learning a multiclass classiﬁer with (strong) convex hull margin  > 0 requires between ⌦  1 + 1   ( m  1) / 2 and ˜
O  k 3 m 1 + 1   m log n  queries.
This exponential dependence on m implies that, unless m ⌧ log n/ log 1  , one needs ⇥ ( n ) LABEL queries in the worst case.
On the other hand our margin implies linear separability and thus, as noted above, a O ( m log n ) SEED query bound for the binary case, but with a running time that can be superpolynomial.
This leaves open the following problem, which is the subject of this work:
Can one learn a multiclass classiﬁer h with strong convex hull margin  > 0 on X ⇢ R m in time poly( n + m ) using a number of queries that grows polynomially with m ?
We solve the above question in the afﬁrmative by proving that, with a careful combination of LABEL and SEED queries, one can do much better than using either query in isolation.
For binary classiﬁcation ( k = 2 ), we show:
Theorem 1.
Any binary classiﬁer h with strong convex hull margin  > 0 over X ⇢ R m can be learned in time poly( n + m ) using in expectation O ( m 2 log n ) LABEL queries and O  m log m   SEED queries.
Note that, unless  is exceedingly small, Theorem 1 uses far fewer SEED than LABEL queries, which is a strength since SEED is arguably more expensive to implement.
For instance, if  = ⌦ (1 / poly( m )) then we use O ( m 2 log n ) LABEL queries but only O ( m log m ) SEED queries.
To prove Theorem 1 we design a novel algorithm that works in two phases.
The ﬁrst phase learns what we call an ↵ -rounding of X w.r.t.
h .
Loosely speaking, this is a partition ( X 1 , X 2 ) of X such that each X i lies inside ↵ conv( C i ) where conv( C i ) is the convex hull of C i (see below for the formal deﬁnition).
We show that, in polynomial time and using O ( m 2 log n ) LABEL queries, one can compute an ↵ -rounding of X i for ↵
= O ( m 3 ) .
This allows us to put X i in near-isotropic position so that X i has radius 1 and to separate C 1 \ X i from C 2 \ X i with margin ⌘ = ⌦ (  /m 3 ) .
In the second phase, the algorithm uses SEED to implement a cutting plane algorithm that learns C 1 \ X i and C [-
 ∩-]2 \ X i using
O  m log 1 ⌘  [Equation] O
[Equation]   queries in time poly( n + m ) .
Using a recursive approach, Theorem 1 can be extended to k > 2 at the price of a k !
k 2 multiplicative overhead:
Theorem 2.
Any k -class classiﬁer h with strong convex hull margin  > 0 over X ⇢ R m can be learned in time poly( n + m ) using in expectation O
( k !
k 2 m 2 log n ) LABEL queries and
O  k !
k 2 m log m   SEED queries.
We also consider the case where only one class has strong convex hull margin against the rest of the points w.r.t.
a metric d induced by a norm k · k d .
In this case we obtain a bound parameterized by the distortion  d of d (see Section 1.1):
Theorem 3.
Suppose C ⇢ X has strong convex hull margin  2 (0 , 1] w.r.t.
a metric d with distortion  d < 1 .
Given only X , one can learn C in time poly( n + m ) using O (log n ) LABEL queries and
O  m log  d   SEED queries in expectation.
As an application of our cutting-plane algorithm we also show that one can learn a k -class classiﬁer whose classes are pairwise linearly separable in time poly( n + m ) using, in expectation, O ( k 2 m 3 B )
SEED queries if every x 2 X has rational coordinates that can be encoded in B bits, and O ( k 2 m ( B + m log m ))
SEED queries if every x 2 X lies on the grid over [  1 , 1] m with stepsize 2  B/m .
It should be noted that, unlike most previous algorithms, all our algorithms do not need knowledge of  .
Moreover, all the bounds above can be turned from expectation to high probability.
Finally, we show that the algorithms of Theorem 1 and 2 are nearly optimal:
Theorem 4.
For all m  2 , all k  2 , and all   m  3 / 2 / 16 there exists a distribution of instances with k classes in R m with strong convex hull margin  where any randomized algorithm using SEED and LABEL queries that returns C with probability at least 12 makes at least [Equation]  total queries in expectation.
1.1 Preliminaries and notation
The input to our problem is a pair ( X, k ) , where X ⇢ R m and k 2 N with 2  k  n = | X | .
The algorithm has access to oracles O LABEL and O SEED which provide respectively LABEL and SEED queries.
The oracles O LABEL , O SEED behave consistently with some target classiﬁer h : X !
[ k ] .
For any x 2 X , LABEL ( x ) returns h ( x ) .
For any U ✓ X and any i 2 [ k ] , SEED ( U, i ) returns an abitrary element x 2 U \ C i if U \ C
i 6 = ; , and NIL otherwise, where C i = h  1 ( i ) .
We often think of h as of the partition C =
( C 1 , . . .
, C k )
and we call each C i a class or cluster .
A pseudometric is a symmetric and subadditive function d : R m ⇥ R m ! R  0 such that d ( x, x ) =
for all x 2 R m ; unlike a metric, d ( x, y ) need not be 0 for x 6 = y .
In this work d is always induced by a seminorm and thus homogeneous and invariant under translation: d ( u + ax, u + ay ) =
| a | d ( x, y ) for all x, y, u 2 R m and all a 2 R .
For a pseudometric d and a set A ⇢ R m , we let  d ( A )
=
sup { d ( x, y ) : x, y 2 A } denote the diameter of A under d .
For x 2 R m and r  0 we denote by B md ( x, r ) and S m  1 d ( x, r ) respectively the closed ball and the hypersphere with center x and radius r in R m under d .
When d is omitted we assume d = d euc where d euc is the Euclidean metric.
We may also omit the superscript if clear from the context.
The distortion of a (pseudometric) d is  d = sup u,v 2 S m  1 (0 , 1)
k u k d / k v k d .
For any set A ⇢ R m , any µ 2 R m , and any  > 0 , let  ( A, µ,  ) =
µ +  ( A  µ ) be the scaling of A about µ by a factor of  .
For two sets A, B ⇢ R m , we write A   B if A ✓  ( B, z,  ) for some z 2 R m .
We may use x in place of A if A = { x } .
If A is bounded, then MVE( A ) denotes the minimum-volume enclosing ellipsoid (MVEE, or Löwner-John ellipsoid) of A .
Our proofs repeatedly use John’s theorem; that is,  ( E, µ, 1 /m ) ✓ conv( A ) where µ is the center of E = MVE
( A ) and conv( A ) is the convex hull of A .
Given A, B ✓ R m , we say that A and B are linearly separable with margin r if there exist u 2 S m  1 (0 , 1) and b 2 R such that h u, x i + b   r for all x 2 A and h u, x i + b  r for all x 2 B .
We consider classiﬁers satisfying the following property:[-
-]
Deﬁnition 5.
A class C i has strong convex hull margin  > 0 if there exists a pseudometric d i induced by a seminorm over R m such that d
i (conv( C j ) , conv( C i )) >
d i ( C i ) for all j 2 [ k ] \{ i } .
If this holds for all i 2 [ k ] then we say C has strong convex hull margin  .
Remarks.
The margin of Deﬁnition 5 captures natural scenarios that SVM margin does not.
For instance, suppose we are clustering fruits on the basis of weight and colour.
First, a fruit weighting more than, say, 1 . 5 times the typical weight of a species probably does not belong to it; but the typical weight varies greatly across species.
Our margin captures this scenario, as it is expressed as a fraction of the class’ diameter.
Second, different fruit species have different separating features; for instance, weight does not separate well oranges from bananas, but colour does.
Our margin captures this aspect, too, by allowing the metric that determines the margin to be a function the class.
It is also known that the SVM margin  SVM can be arbitrarily smaller than  ; for instance there are simple cases with  > {+
+} but  SVM <
e  n (see Bressan et al.
[2021a]).
Hence a large  does not imply good bounds for standard algorithms based on SVM margin (e.g., the Perceptron).
Related work
It is well known that active learning may achieve exponential savings in label complexity.
That is, there are natural concept classes that can be learned with a number of LABEL queries exponentially smaller than that of passive learning.
Hanneke and Yang [2015] characterize the label complexity of concept classes in terms of their star number.
However, the star number of many natural classes such as linear classiﬁers is unbounded, implying a strong lower bound of ⌦ ( n ) LABEL queries.
This and other negative results motivated research on enriched queries.
Kane et al.
[2017] prove that active learnability is characterized by the inference dimension of the concept class H under the set of allowed queries Q , as long as those queries are local (i.e., are a function of a constant number of instances).
This yields exponential savings when H is the class of linear separators and
Q contains label queries and comparison queries (which, given two points, reveal which one is closer to the decision boundary), provided the classes have SVM margin or bounded bit complexity.
Hopkins et al.
[2020] give similar results under distributional assumptions.
Unfortunately, bounded inference dimension does not automatically yield efﬁcient algorithms, although it implies active learning algorithms with bounded memory [Hopkins et al., 2021].
SEED and their variants are motivated and used by Hanneke [2009] as positive example queries , by Balcan and Hanneke [2012] as conditional class queries , and by Beygelzimer et al.
Attenberg and Provost [2010] as search queries .
They are also used implicitly by Tong and Chang [2001], Doyle et al.
[2011], and Vikram and Dasgupta [2016].
SEED queries have been used in cluster recovery [Bressan et al., 2021b] and yield exponential savings in non-realizable learning settings [Balcan and Hanneke, 2012].
It also easy to see that SEED queries are equivalent to partial equivalence queries of Maass and Turán [1992] and to subset plus superset queries of Angluin [1988].
To the best of our knowledge, no work combines LABEL and SEED as we do here.
Little is known about the SEED complexity of learning a concept class H actively in polynomial time.
On the one hand, the inference dimension lower bounds of Kane et al.
[2017] are inapplicable, as SEED queries are not local.
On the other hand the Littlestone dimension of H yields an upper bound, but not necessarily an efﬁcient algorithm; in fact, it is well known that (some sub-problem solved by)
Halving is hard in general, see Gonen et al.
For k = 2 , we can use SEED to emulate equivalence queries, for which polynomial-time algorithms are known in some special cases.
In particular, the algorithm of Maass and Turán [1994] could replace our cutting-planes subroutine under an implicit discretization of the space through a grid with step-size O (  / m 4 ) .
However, this gives a polynomial-time algorithm that uses O ( m 2 log m /  ) SEED queries, which is O ( m ) times our bound.
Moreover, Maass and Turán [1994] use proper equivalence queries (i.e., the queried concept must be in the class), for which they show a lower bound of ⌦ ( m 2 log m /  ) .
Finally, these techniques do not seem to extend to the case k > 2 .
Our notion of margin strengthens the convex hull margin of Bressan et al.
[2021a] by requiring d (conv( C j ) , conv( C i )) >
( C i ) rather than d ( C j , C i ) >  ( C i ) .
It is not hard to see that the convex hull margin can be arbitrarily smaller than our strong convex hull margin.
Finally, the polytope margin of Gottlieb et al.
[2018] assumes that each class is in the intersection of a ﬁnite number of halfspaces with margin.
It is easy to see that this condition is strictly stronger than ours.
Upper Bounds
This section gives the proofs of Theorem 1 and Theorem 2.
The algorithm behind both theorems has two phases which are described in the next subsections.
The case k > 2 is essentially the same as for k = 2 , except for an adaptation in the second phase.
3.1 The First Phase: Rounding the Classes
The ﬁrst phase of our algorithms learns what we call an ↵ -rounding of X .
Deﬁnition 6.
An ↵ -rounding of X (w.r.t.
h ) is a sequence of pairs (( X i , E i ))
i 2 [ k ] where ( X i ) i {+
+}
[ k ] is a partition of X , and where E i for i 2 [ k ] is an ellipsoid such that X i ✓ E i and E i  ↵ conv( C i ) .
The idea is that, if (( X i , E i ))
i 2 [ k ] is an ↵ -rounding of X , then E i gives an approximation of the pseudometric d i witnessing the strong convex hull margin of C i .
Indeed, let p i be the pseudometric induced by E i , the one such that E i =
B p i ( µ i , 1) where µ i is the center of E i ; we prove:
Lemma 7.
If (( X i , E i ))
i 2 [ k ] is an ↵ -rounding of X then p i (conv( X i \ C i ) , conv( X i \ C j ))  ↵ for all distinct i, j 2 [ k ] . Proof.
If µ i is the center of E i , then E i = B p i ( µ i , 1) .
Let d i be any pseudometric witnessing that C i has strong convex hull margin  > 0 . As the margin is invariant under scaling, we can assume  d i ( C i ) = 1 and conv( C i ) ✓ B d i ( z i , 1) for some z
i 2 R m .
Therefore:
[Equation]
As p i and d i are homogeneous and invariant under translation this implies p i  d i ↵ and thus p i (conv( X i \ C j ) , conv( X i \ C i ))
1 ↵ d i (conv( X i \ C j ) , conv( X i \ C i )) .
Moreover, by monotonicity under taking subsets and by the margin assumption d i (conv( X i \ C j ) , conv( X i \ C i ))
d i (conv( C j ) , conv( C i ))
d i ( C i ) =  .
Combining the two inequalities yields the thesis.
We will use Lemma 7 in the second phase.
First, we show how to compute an ↵ -rounding of X efﬁciently.
We sample points independently and uniformly at random from X until we ﬁnd ⇥ ( m 2 ) points S i with the same label i .
As the VC dimension of ellipsoids in R m is O ( m 2 ) , by standard generalization error bounds with constant probability the MVE of S i contains at least half of C i .
We then store that MVE together with the index i , remove S i from X , and repeat until X becomes empty.
At that point for each i 2 [ k ] we “merge” together all points in the MVEs that were computed for class i , and compute the MVE of this merged set.
We show that this produces an ↵ -rounding of X after O ( k log n ) rounds in expectation.
The resulting algorithm Round is listed below; Figuredepicts its behaviour on a toy example.
Lemma 8.
Round( X, k ) returns an m 2 ( m + 1) -rounding of X in time poly( n + m ) using
O ( k 2 m
2 log n ) LABEL queries in expectation.
Proof sketch.
First we show that E i  m 2 ( m + 1) conv( C i ) for all i 2 [ k ] .
This is trivial if E i = ; , so let E i 6 = ; and let ` i  1 be the value of h i at return time.
For every h = 1 , . . . , ` i let E hi =
MVE( S hi ) and let µ hi be the center of E hi .
Using John’s theorem one can show that   E [Equation]
m  ✓ conv S ` i h =1   conv( S hi ) , µ hi , m  and   conv( S hi ) , µ hi , m  ✓  (conv( C i ) , µ, m ( m + 1)) .
By taking the union over all h 2 [ ` i ] we conclude that
E i , µ i , 1 m  ✓  (conv( C i ) , µ, m ( m + 1)) , that is, E i  m 2 ( m +1) conv( C i ) .
It is also easy so see that ( X i ) i {+
+}
[ k ] is a partition of X , hence (( X i , E i ))
i 2 [ k ] is an m 2 ( m +1)
-rounding of X .
For the running time, the for loops perform k  n iterations, and the while loop performs at most n iterations as each iteration strictly decreases the size of X .
The running time of any iteration is dominated by the computation of MVE( S i ) or MVE( X i ) , which takes time poly( n + m ) , see above.
Hence Round( X, k ) runs in time poly( n + m ) .
For the query bounds, the while loop makes
O ( m 2 k ) LABEL queries per iteration.
By standard generalization bounds, since the VC dimension of [Equation] for i 2 [ k ] do h i while X 6 = ; do draw points independently u.a.r. from X and LABEL them until for some i 2 [ k ] we draw a (multi)set of cm 2 points from C i
h
i h
i +
S h
i i the sample of cm 2 points from C
i
X h
i
i
X \ MVE( S h i i )
X
X \ X h
{+i i for i 
+}
[ k ] do
X i
X 1 i [ . . .
[ X h i
i (set to ; if h i = 0 ) E i
MVE( X i ) (set to ; if X i = ; ) return (( X i , E i ))
i 2 [ k ]
[Figure]
ellipsoids in R m is O ( m 2 ) , E hi contains at least half of X \ C i with probability at least 12 , and thus the expected number of rounds before X becomes empty is in O ( k lg n ) , see Bressan et al.
[2021a].
We conclude that Round( X, k ) uses O ( m 2 k 2 lg n ) LABEL queries in expectation.
3.2 The Second Phase: Finding a Separator via Cutting Planes
Let (( X i , E i ))
i 2 [ k ] be the output of Round( X, k ) , and ﬁx i 2 [ k ] .
For each j 2 [ k ] \ { i } , we want to separate X
i \ C
i from X i \ C j .
To this end, ﬁrst we use E i to perform a change of coordinates; this puts X i inside the unit ball and ensures that X i \ C i and X i \ C j are linearly separated with margin  SVM =
⌦ (  m  3 ) .
Next, by calling C i the positive class ( +1 ) and C j the negative class (  1 ), and letting X = X i for simplicity, one can reduce the task to the following problem.
Consider a partial classiﬁer h : X ! {
+1 ,  1 , ⇤ } .
The algorithm has access to an oracle answering queries
SEED ( U, y ) where U ✓ X and y 2 { +1 ,  1 } , and its goal is to compute a separator of X :
Deﬁnition 9.
Let X ⇢ R m and h : X ! { +1 ,  1 , ⇤ } .
A separator of X (w.r.t.
h ) is a partition ( X + , X  ) of X such that, for every x 2 X , if h ( x ) =
+1 then x 2 X
+ and if h ( x ) =  1 then x 2 X  .
A separator of X can be learned, for instance, by the Perceptron (using SEED to ﬁnd counterexamples).
However, this would yield a query and running time bound of O (1 /  2 SVM )
=
O ( m 6 /  2 ) .
We provide
CPLearn , a cutting-plane algorithm based on SEED that is much more query-efﬁcient (in fact, near-optimal):
Theorem 10.
Let X ⇢ R m and h : X ! { +1 ,  1 , ⇤ } , and suppose h  1 (+1) and h  1 (  1) are linearly separable with margin r .
Given X and access to SEED for labels [Equation] computes a separator of X w.r.t.
h using O ( m log Rr ) SEED queries in expectation, where R = max x 2 X k x k 2 , and running with high probability 6 in time poly( m + | X | ) .
Proof.
( Sketch )
First, we lift X to R m +1 .
This reduces the problem to ﬁnding a homogeneous linear separator.
To this end we let X 0 = { x 0 : x 2 X } where x 0 is obtained by appending to x an ( m +1) -th coordinate that is equal to R , and we extend h to X 0 in the obvious way.
It is easy to prove that X 0 has radius at most 2 R and that in X 0 the two classes are linearly separable with margin r 2 .
Next, we learn a separator of X 0 w.r.t.
h via cutting planes—see, e.g., Mitchell [2003].
Let V 0 =
B m +
Every point u 2 V 0 identiﬁes the halfspace H ( u ) =
{ z 2 R m +1 : h u, z i  0 } .
For i = 1 , 2 , . . .
, V i will be our version space, and we compute V i +1 from V i as follows.
Let µ i be the center of mass of V i , and let X 0 i =
X 0 \ H ( µ i ) .
By issuing SEED ( X 0 i ,  1) and SEED ( X 0 \ X {+
+}
i , +1) we learn whether ( X 0 i , X 0 \ X 0 i ) is a separator of X 0 w.r.t.
h , in which case we return the corresponding partition of X , or we obtain a point u i .
In the second case, we let V i +
= V i \
U i where U
i = { x
R m +1 : h ( u i ) · h u i , x i  0 } .
By [Gilad-Bachrach et al., 2004, Theorem 2] this procedure returns a separator of X 0 w.r.t.
h using at most
[Equation]
queries. Unfortunately, computing µ i is hard in general [Rademacher, 2007].
We instead compute an estimate ˆ µ i that, used in place of µ i , ensures vol( V i +1 ) vol
( V i ) is bounded away from 1 with high probability; the expected query bound follows by adapting the proof of [Gilad-Bachrach et al., 2004].
Assume for the moment that V i is well-rounded—that is, it contains a ball of radius r = poly( m ) and is contained in a ball of radius 1 .
To compute ˆ µ i we average over poly( n + m ) independent uniform points from
V i , which can be draw efﬁciently thanks to the rounding condition.
At this point we use ˆ µ i in place of µ i to invoke SEED and obtain a violated constraint U i .
Howewer, setting V i
+
= V i \
U i could make V
i +1 far from rounded (too “thin”), making sampling inefﬁcient at the next round.
Therefore we rotate U i so to obtain a weaker constraint U ⇤ i , one that still contains V i \ U i
but that has ˆ µ i on its boundary, and let V i +
= V i \ U ⇤ i .
By the assumption on ˆ µ
i
this implies that vol( V i +1 )  13 vol( V i ) ; therefore by sampling uniform points from V i we can obtain a large sample in V
i +1 ,
from which we can put V i +1 in a rounding position.
See the full proof for all the details.
To the best of our knowledge, CPLearn is the ﬁrst efﬁcient algorithm that achieves the query upper bound of Theorem 10, even for the special case of SVM margin.
3.3 Wrap-Up
We wrap up our algorithms, starting with the case k = 2 ; the case k  2 is slightly more involved.
Algorithm 2: BinLearn( X ) (( X 1 , E 1 ) , ( X 2 , E 2 ))
Round( X ) for i 1 , 2 do change system of coordinates so that E i becomes the unit ball ( X i + , X i  ) CPLearn( X i ) with h : X i ! { 1 , 2 } return ( [Equation]
Theorem 11.
Suppose k = 2 .
Then BinLearn( X ) returns C
= ( C 1 , C 2 ) in time poly( n + m ) using in expectation O ( m 2 log n ) LABEL queries and O ( m log m  ) SEED queries.
Proof.
By Lemma 8, Round( X ) runs in time poly( n + m ) , makes O ( m 2 log n ) LABEL queries in expectation, and returns an O ( m 3 ) -rounding of X .
It is immediate to see that, after the change of coordinates, X i has radius R  1 , while C 1 \ X 1 and C [-
 ∩-]2 \ X 1 are separated linearly with margin r = ⌦ (  m  3 ) .
By Theorem 10 then, CPLearn( X i ) returns the partition of X i induced by h in time poly( | X i | + m )
= poly( n + m ) using O
[Equation]
For k  2 we proceed as follows.
Let k =
[ k ] .
We take X i for each i 2 k in turn, and for each j 2 k \ i , we use CPLearn to compute a separator for i, j in X i .
By intersecting the left side of all those separators we obtain X i \ C i .
Then we recurse on X i \ C i , updating k to k \ i .
The resulting algorithm KClassLearn is listed below and yields:
Theorem 12.
KClassLearn( X, [ k ]) returns C in time poly( n + m ) using in expectation
O ( k !
k
2 m 2 log n ) LABEL queries and O  k !
k 2 m log m   SEED queries.
Proof.
We adapt the proof of Theorem 11.
Observe that KClassLearn( X, [ k ]) makes at most min( k ! , n ) recursive calls; the n in the min comes from the fact that any given (recursive) call learns the label of at least one unlabeled point.
Now, every (recursive) call makes one invocation to Round( X ) , which by Lemma 8 uses time poly( n + m ) and O ( k 2 m 2 log n ) LABEL queries, and
O ( k 2 ) invocations to CPLearn( X i ) , each of which by Theorem 10 uses poly( n + m ) time and
O  m log m   SEED queries.
Algorithm 3: k | k | if k = 1 then query any point of X and label all of X accordingly else (( X i , E i ))
i 2 [ k ]
Round( X ) for i 2 k do change system of coordinates so that E i becomes the unit ball for j 2 k \ i do ( C ij , C ij ) CPLearn( X i ) with h : X i ! { i, j } b
C i T j 2 k \ i C ij mark all of b C i with label i if X i \ b
C i 6 = ; then KClassLearn( X i \ b C i , k [Equation]
Lower Bounds
This section gives a detailed sketch of the proof of Theorem 4, recalled here for convenience:
Theorem 4.
For all m  2 , all k  2 , and all   m  3 / 2 / 16 there exists a distribution of instances with k classes in R m with strong convex hull margin  where any randomized algorithm using SEED and LABEL queries that returns C with probability at least 12 makes at least ⌅ k⇧ m 24 log 12  total queries in expectation.
We ﬁrst give the sketch for k = 2 , and then extend it to k  2 .
For a full proof see Appendix B. Setup.
The construction is adapted from Proposition 2 of Thiessen and Gärtner [2021].
Let e 1 , . .
, e m be the canonical basis of R m and let ` = b 1 / p 2  p m c ; note that   m  3 / 2and m  2 ensure `  4 .
Let p = m  1 , and for each i 2 [ p ] and j 2 [ ` ] deﬁne x ji = e i + j · e m .
Finally, let X =
{ x ji : i 2 [ p ] , j 2 [ ` ] } and deﬁne the concept class H = nS i 2 [ p ] { x 1 i , . .
, x ` i i } : ( ` 1 , . . . , ` p ) 2 [ ` ] p o .
Let
C =
( C 1 , C 2 ) be any partition of X such that C 1 2 H .
One can easily verify that C has strong convex hull margin 1 {+
 `+} 2 p m   .
See Figure 2 for reference.
Query bound.
Let V
= { ( C 1 , C 2 ) :
C 1 2 H} .
This is the initial version space.
We let the target concept
C = ( C 1 , C 2 ) be drawn uniformly at random from V 0 .
Note that for k = 2 , any lower bound on the number of SEED queries alone, also holds for any combination of SEED and LABEL queries, as
LABEL ( x ) can be simulated by SEED ( x, 1) .
Thus, without loss of generality, we can assume that the algorithm is only using SEED queries.
For all t = 0 , 1 , . . .
, we denote by V t the version space after the ﬁrst t SEED queries made by the algorithm.
Now ﬁx any t  1 and let SEED ( U, y ) be the t -th such query.
Without loss of generality we assume y = 1 ; a symmetric argument applies to y = 2 .
If
U \ C 1 contains a point x whose label can be inferred from the ﬁrst t  1 queries, then we return
S+ + + + +
S+ +         [Figure] U x . Therefore we can continue under the assumption that U does not contain any such point (doing otherwise cannot reduce the probability that the algorithm learns nothing).
The oracle answers so to maximize | V t | | V t  1 | , as described below.
For each i 2 [ p ] let S i
= { x ji : j 2 [ ` ] } .
We consider S i as sorted by the index j .
Let Z i be the subset of S i in the disagreement region of V t  1 together with the point in S i preceding this region; observe that this point always exists, as x 1 i 2 C 1 is in the agreement region.
Note that Z i is necessarily an interval of S i .
We let U i
= Z i \ U for each i 2 [ p ] and P ( U ) =
{ i 2 [ p ] : U i 6 = ; } .
For every i 2 P ( U ) , we let ↵ i be the fraction of points of Z i that precede the ﬁrst point in U i .
Let x ⇤ i = arg max { j : x ji 2 S i \ C 1 } .
Observe that | V t  1 | =
Q i 2 [ p ] | Z i | .Indeed, x ⇤ i is uniformly distributed over Z i ; either x ⇤ i is a point in the disagreement region of S i , or the disagreement region of S i is fully contained in C 2 and x ⇤ i is the point preceding the disagreement region of S i .
Now we show that E [ | V t  1 | / | V t | ]  m .
Let E be the event that SEED ( U, 1)
=
NIL .
Write:
[Equation]
[Equation]
We bound each one of the two terms in the right-hand side.
For the ﬁrst term, note that E holds if and only if U i \ C 1 = ; for all i 2 P ( U ) .
Since x ⇤ i is uniformly distributed over Z i , for all i 2 P ( U ) we have Pr( C 1 \ U
i = ; )
= ↵ i , and since the distributions of those points are independent, then Pr( E ) =
Q i 2 P ( U ) ↵ i .
If Pr( E ) > 0 and E holds, then x ⇤ i is uniformly distributed over the ﬁrst ↵ i | Z i | points of Z i , as the rest of Z i belongs to C 2 .
This holds independently for all i , thus:
[Equation]
It follows that Pr( E ) E h
[Equation]
[Equation]
Let us turn to the second term.
If E does not hold, then SEED ( U, 1) returns the smallest point x 2 U i for any i 2 P ( U ) such that C 1 \ U i 6 = ; (note that necessarily x 2 C 1 ).
For any ﬁxed i 2 P ( U ) , the probability of returning the smallest point of U i is bounded by Pr( C 1 \ U i 6 = ; ) , which is 1  ↵ i ; and if this is the case, then we have | V t | =
(1  ↵ i ) | V t  1 | .
Thus:
[Equation]
So the two terms of (2) are both bounded by 1 ; we conclude that E [Equation]
Next, ﬁx any ¯ t  1 and let log = log 2 .
By the concavity of log and by Jensen’s inequality:
[Equation]
Since E h | V [Equation] 1 | | V t | i  2 , the right-hand side is at most ¯ t .
Now, since | V 0 | = ` p = ` m  1 , by Markov’s inequality, and since ( m  1) log `  log 2  ( m  1)log ` m log `: [Equation]
=
[Equation]
Now let T be the random variable counting the number of queries spent by the algorithm, and let V T be the version space at return time.
Since C is uniform over V T and C is returned with probability at least 12 , then Pr( | V T |  2)  12 .
By (6) and linearity of expectation,
[Equation]
Therefore E [ T ]  m log `.
Now, since `  4 then `  4 5 p 2  p m , which since m  (16  )  2 / 3 yields, after calculations, ` p 1 /  · 4 4 / 3 5 p 2 > 0 . 89p 1 /  .
This shows that E [ T ] > m 24 log 12  , concluding the proof for k = 2 .
Extension to k  2.
For each s⌅ k⇧ and each pair of classes C 2 s  1 , C 2 s , use the construction above shifted along the m -th dimension by ( s  1) ` .
One can easily verify that learning C is as hard as learning ⌅ k⇧ independent binary classiﬁers, for each of which the bound above holds.  Conclusions and Future Work
We have shown that, with a careful combination of LABEL and SEED queries, one can overcome the limitations of each query alone and get the “best of both worlds”: an algorithm that achieves exponential savings and, simultaneously, has running time polynomial in the dimension of the space.
Our work leaves open a few problems. The ﬁrst problem is to understand the tradeoff between the two query types: how many LABEL does one need if one is allowed only Q SEED ? The second problem is whether, for the one-sided case, one can achieve a query rate that is independent of the distortion  d , as we did for the multiclass case. The third problem is whether one can improve the dependence of our bounds on the number k of classes, ideally bounding it by a polynomial.
The authors gratefully acknowledge partial support by the Google Focused Award “Algorithms and Learning for AI” (ALL4AI). Nicolò Cesa-Bianchi is also supported by the MIUR PRIN grant Algorithms, Games, and Digital Markets (ALGADIMAR) and by the EU Horizon 2020 ICTresearch and innovation action under grant agreement 951847, project ELISE (European Learning and Intelligent Systems Excellence).
For all authors... (a) Do the main claims made in the abstract and introduction accurately reﬂect the paper’s contributions and scope?
[Yes] (b) Did you describe the limitations of your work?
[Yes] We clearly state the assumptions under which our results hold.
(c) Did you discuss any potential negative societal impacts of your work?
[Yes] This is a purely theoretical work with no direct societal impact, neither positive nor negative.
(d) Have you read the ethics review guidelines and ensured that your paper conforms to them?
[Yes] 2.
If you are including theoretical results... (a) Did you state the full set of assumptions of all theoretical results?
[Yes] (b) Did you include complete proofs of all theoretical results?
[Yes] 3.
If you ran experiments... (a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)?
[N/A] (b) Did you specify all the training details (e
g., data splits, hyperparameters, how they were chosen)?
[N/A] (c) Did you report error bars (e
g., with respect to the random seed after running experiments multiple times)?
[N/A] (d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)?
[N/A] 4.
If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... (a) If your work uses existing assets, did you cite the creators?
[N/A] (b) Did you mention the license of the assets?
[N/A] (c) Did you include any new assets either in the supplemental material or as a URL?
[N/A] (d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating?
[N/A] (e) Did you discuss whether the data you are using/curating contains personally identiﬁable information or offensive content?
[N/A] 5.
If you used crowdsourcing or conducted research with human subjects... (a) Did you include the full text of instructions given to participants and screenshots, if applicable?
[N/A] (b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable?
[N/A] (c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation?
[N/A]