ShareBoost: Efficient Multiclass Learning with Feature Sharing

by   Shai Shalev-Shwartz, et al.

Multiclass prediction is the problem of classifying an object into a relevant target class. We consider the problem of learning a multiclass predictor that uses only few features, and in particular, the number of used features should increase sub-linearly with the number of possible classes. This implies that features should be shared by several classes. We describe and analyze the ShareBoost algorithm for learning a multiclass predictor that uses few shared features. We prove that ShareBoost efficiently finds a predictor that uses few shared features (if such a predictor exists) and that it has a small generalization error. We also describe how to use ShareBoost for learning a non-linear predictor that has a fast evaluation time. In a series of experiments with natural data sets we demonstrate the benefits of ShareBoost and evaluate its success relatively to other state-of-the-art approaches.



There are no comments yet.


page 12


Focus of Attention for Linear Predictors

We present a method to stop the evaluation of a prediction process when ...

Deep KKL: Data-driven Output Prediction for Non-Linear Systems

We address the problem of output prediction, ie. designing a model for a...

On Anytime Learning at Macroscale

Classical machine learning frameworks assume access to a possibly large ...

SafePredict: A Meta-Algorithm for Machine Learning That Uses Refusals to Guarantee Correctness

SafePredict is a novel meta-algorithm that works with any base predictio...

Feedback Detection for Live Predictors

A predictor that is deployed in a live production system may perturb the...

kd-switch: A Universal Online Predictor with an application to Sequential Two-Sample Testing

We propose a novel online predictor for discrete labels conditioned on m...

Testing using Privileged Information by Adapting Features with Statistical Dependence

Given an imperfect predictor, we exploit additional features at test tim...
This week in AI

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

1 Introduction

Learning to classify an object into a relevant target class surfaces in many domains such as document categorization, object recognition in computer vision, and web advertisement. In multiclass learning problems we use training examples to learn a classifier which will later be used for accurately classifying new objects. Typically, the classifier first calculates several features from the input object and then classifies the object based on those features. In many cases, it is important that the runtime of the learned classifier will be small. In particular, this requires that the learned classifier will only rely on the value of few features.

We start with predictors that are based on linear combinations of features. Later, in Section 4

, we show how our framework enables learning highly non-linear predictors by embedding non-linearity in the construction of the features. Requiring the classifier to depend on few features is therefore equivalent to sparseness of the linear weights of features. In recent years, the problem of learning sparse vectors for linear classification or regression has been given significant attention. While, in general, finding the most accurate sparse predictor is known to be NP hard

[25, 10], two main approaches have been proposed for overcoming the hardness result. The first approach uses norm as a surrogate for sparsity (e.g. the Lasso algorithm [34] and the compressed sensing literature [6, 12]). The second approach relies on forward greedy selection of features (e.g. Boosting [16]

in the machine learning literature and orthogonal matching pursuit in the signal processing community


A popular model for multiclass predictors maintains a weight vector for each one of the classes. In such case, even if the weight vector associated with each class is sparse, the overall number of used features might grow with the number of classes. Since the number of classes can be rather large, and our goal is to learn a model with an overall small number of features, we would like that the weight vectors will share the features with non-zero weights as much as possible. Organizing the weight vectors of all classes as rows of a single matrix, this is equivalent to requiring sparsity of the columns of the matrix.

In this paper we describe and analyze an efficient algorithm for learning a multiclass predictor whose corresponding matrix of weights has a small number of non-zero columns. We formally prove that if there exists an accurate matrix with a number of non-zero columns that grows sub-linearly with the number of classes, then our algorithm will also learn such a matrix. We apply our algorithm to natural multiclass learning problems and demonstrate its advantages over previously proposed state-of-the-art methods.

Our algorithm is a generalization of the forward greedy selection approach to sparsity in columns. An alternative approach, which has recently been studied in [28, 13], generalizes the norm based approach, and relies on mixed-norms. We discuss the advantages of the greedy approach over mixed-norms in Section 1.2.

1.1 Formal problem statement

Let be the set of objects we would like to classify. For example, can be the set of gray scale images of a certain size. For each object , we have a pool of predefined features, each of which is a real number in . That is, we can represent each as a vector of features . We note that the mapping from to can be non-linear and that can be very large. For example, we can define so that each element corresponds to some patch, , and a threshold , where equals if there is a patch of whose inner product with is higher than . We discuss some generic methods for constructing features in Section 4. From this point onward we assume that is given.

The set of possible classes is denoted by . Our goal is to learn a multiclass predictor, which is a mapping from the features of an object into . We focus on the set of predictors parametrized by matrices that takes the following form:


That is, the matrix maps each -dimensional feature vector into a -dimensional score vector, and the actual prediction is the index of the maximal element of the score vector. If the maximizer is not unique, we break ties arbitrarily.

Recall that our goal is to find a matrix with few non-zero columns. We denote by the ’th column of and use the notation

to denote the number of columns of which are not identically the zero vector. More generally, given a matrix and a pair of norms we denote , that is, we apply the -norm on the columns of and the -norm on the resulting -dimensional vector.

The loss of a multiclass predictor on an example is defined as . That is, the loss equals if and

otherwise. Since this loss function is not convex with respect to

, we use a surrogate convex loss function based on the following easy to verify inequalities:


We use the notation to denote the right-hand side (eqn. (3)) of the above. The loss given in eqn. (2) is the multi-class hinge loss [8]

used in Support-Vector-Machines, whereas

is the result of performing a “soft-max” operation: , where equality holds for .

This logistic multiclass loss function has several nice properties — see for example [40]. Besides being a convex upper-bound on the loss, it is smooth. The reason we need the loss function to be both convex and smooth is as follows. If a function is convex, then its first order approximation at any point gives us a lower bound on the function at any other point. When the function is also smooth, the first order approximation gives us both lower and upper bounds on the value of the function at any other point111Smoothness guarantees that for some and all . Therefore one can approximate by and the approximation error is upper bounded by the difference between .. ShareBoost uses the gradient of the loss function at the current solution (i.e. the first order approximation of the loss) to make a greedy choice of which column to update. To ensure that this greedy choice indeed yields a significant improvement we must know that the first order approximation is indeed close to the actual loss function, and for that we need both lower and upper bounds on the quality of the first order approximation.

Given a training set , the average training loss of a matrix is: We aim at approximately solving the problem


That is, find the matrix with minimal training loss among all matrices with column sparsity of at most , where is a user-defined parameter. Since is an upper bound on , by minimizing we also decrease the average error of over the training set. In Section 5 we show that for sparse models, a small training error is likely to yield a small error on unseen examples as well.

Regrettably, the constraint in eqn. (4) is non-convex, and solving the optimization problem in eqn. (4) is NP-hard [25, 10]. To overcome the hardness result, the ShareBoost algorithm will follow the forward greedy selection approach. The algorithm comes with formal generalization and sparsity guarantees (described in Section 5) that makes ShareBoost an attractive multiclass learning engine due to efficiency (both during training and at test time) and accuracy.

1.2 Related Work

The centrality of the multiclass learning problem has spurred the development of various approaches for tackling the task. Perhaps the most straightforward approach is a reduction from multiclass to binary, e.g. the one-vs-rest or all pairs constructions. The more direct approach we choose, in particular, the multiclass predictors of the form given in eqn. (1), has been extensively studied and showed a great success in practice — see for example [14, 38, 8].

An alternative construction, abbreviated as the single-vector model, shares a single weight vector, for all the classes, paired with class-specific feature mappings. This construction is common in generalized additive models [18], multiclass versions of boosting [17, 29], and has been popularized lately due to its role in prediction with structured output where the number of classes is exponentially large (see e.g. [32]). While this approach can yield predictors with a rather mild dependency of the required features on (see for example the analysis in [40, 32, 15]), it relies on a-priori assumptions on the structure of and . In contrast, in this paper we tackle general multiclass prediction problems, like object recognition or document classification, where it is not straightforward or even plausible how one would go about to construct a-priori good class specific feature mappings, and therefore the single-vector model is not adequate.

The class of predictors of the form given in eqn. (1) can be trained using Frobenius norm regularization (as done by multiclass SVM – see e.g. [8]) or using regularization over all the entries of . However, as pointed out in [28], these regularizers might yield a matrix with many non-zeros columns, and hence, will lead to a predictor that uses many features.

The alternative approach, and the most relevant to our work, is the use of mix-norm regularizations like or [22, 37, 2, 3, 28, 13, 20]. For example, [13] solves the following problem:


which can be viewed as a convex approximation of our objective (eqn. (4)). This is advantageous from an optimization point of view, as one can find the global optimum of a convex problem, but it remains unclear how well the convex program approximates the original goal. For example, in Section 6 we show cases where mix-norm regularization does not yield sparse solutions while ShareBoost does yield a sparse solution. Despite the fact that ShareBoost tackles a non-convex program, and thus limited to local optimum solutions, we prove in Theorem 2 that under mild conditions ShareBoost is guaranteed to find an accurate sparse solution whenever such a solution exists and that the generalization error is bounded as shown in Theorem 1.

We note that several recent papers (e.g. [20]) established exact recovery guarantees for mixed norms, which may seem to be stronger than our guarantee given in Theorem 2. However, the assumptions in [20] are much stronger than the assumptions of Theorem 2. In particular, they have strong noise assumptions and a group RIP like assumption (Assumption 4.1-4.3 in their paper). In contrast, we impose no such restrictions. We would like to stress that in many generic practical cases, the assumptions of [20] will not hold. For example, when using decision stumps, features will be highly correlated which will violate Assumption 4.3 of [20].

Another advantage of ShareBoost is that its only parameter is the desired number of non-zero columns of . Furthermore, obtaining the whole-regularization-path of ShareBoost, that is, the curve of accuracy as a function of sparsity, can be performed by a single run of ShareBoost, which is much easier than obtaining the whole regularization path of the convex relaxation in eqn. (5). Last but not least, ShareBoost can work even when the initial number of features, , is very large, as long as there is an efficient way to choose the next feature. For example, when the features are constructed using decision stumps, will be extremely large, but ShareBoost can still be implemented efficiently. In contrast, when is extremely large mix-norm regularization techniques yield challenging optimization problems.

As mentioned before, ShareBoost follows the forward greedy selection approach for tackling the hardness of solving eqn. (4

). The greedy approach has been widely studied in the context of learning sparse predictors for linear regression. However, in multiclass problems, one needs sparsity of groups of variables (columns of

). ShareBoost generalizes the fully corrective greedy selection procedure given in [30] to the case of selection of groups of variables, and our analysis follows similar techniques.

Obtaining group sparsity by greedy methods has been also recently studied in [21, 24], and indeed, ShareBoost shares similarities with these works. We differ from [21] in that our analysis does not impose strong assumptions (e.g. group-RIP) and so ShareBoost applies to a much wider array of applications. In addition, the specific criterion for choosing the next feature is different. In [21], a ratio between difference in objective and different in costs is used. In ShareBoost, the L1 norm of the gradient matrix is used. For the multiclass problem with log loss, the criterion of ShareBoost is much easier to compute, especially in large scale problems. [24] suggested many other selection rules that are geared toward the squared loss, which is far from being an optimal loss function for multiclass problems.

Another related method is the JointBoost algorithm [35]. While the original presentation in [35] seems rather different than the type of predictors we describe in eqn. (1), it is possible to show that JointBoost in fact learns a matrix with additional constraints. In particular, the features are assumed to be decision stumps and each column is constrained to be , where and . That is, the stump is shared by all classes in the subset . JointBoost chooses such shared decision stumps in a greedy manner by applying the GentleBoost algorithm on top of this presentation. A major disadvantage of JointBoost is that in its pure form, it should exhaustively search among all possible subsets of . In practice, [35]

relies on heuristics for finding

on each boosting step. In contrast, ShareBoost allows the columns of to be any real numbers, thus allowing ”soft” sharing between classes. Therefore, ShareBoost has the same (or even richer) expressive power comparing to JointBoost. Moreover, ShareBoost automatically identifies the relatedness between classes (corresponding to choosing the set ) without having to rely on exhaustive search. ShareBoost is also fully corrective, in the sense that it extracts all the information from the selected features before adding new ones. This leads to higher accuracy while using less features as was shown in our experiments on image classification. Lastly, ShareBoost comes with theoretical guarantees.

Finally, we mention that feature sharing is merely one way for transferring information across classes [33] and several alternative ways have been proposed in the literature such as target embedding [19, 5], shared hidden structure [23, 1], shared prototypes [27], or sharing underlying metric [39].

2 The ShareBoost Algorithm

ShareBoost is a forward greedy selection approach for solving eqn. (4). Usually, in a greedy approach, we update the weight of one feature at a time. Now, we will update one column of at a time (since the desired sparsity is over columns). We will choose the column that maximizes the norm of the corresponding column of the gradient of the loss at . Since is a matrix we have that is a matrix of the partial derivatives of . Denote by the ’th column of , that is, the vector . A standard calculation shows that



Note that for all . Therefore, we can rewrite,

Based on the above we have


Finally, after choosing the column for which is maximized, we re-optimize all the columns of which were selected so far. The resulting algorithm is given in Algorithm 1.

1:  Initialize:  ; 
2:  for t=1,2,…,T do
3:     For each class and example define as in eqn. (6)
4:     Choose feature that maximizes the right-hand side of eqn. (7)
6:     Set s.t. for all
7:  end for
Algorithm 1 ShareBoost

The runtime of ShareBoost is as follows. Steps 3-5 requires . Step 6 is a convex optimization problem in variables and can be performed using various methods. In our experiments, we used Nesterov’s accelerated gradient method [26] whose runtime is for a smooth objective, where is the desired accuracy. Therefore, the overall runtime is . It is interesting to compare this runtime to the complexity of minimizing the mixed-norm regularization objective given in eqn. (5). Since the objective is no longer smooth, the runtime of using Nesterov’s accelerated method would be which can be much larger than the runtime of ShareBoost when .

3 Variants of ShareBoost

We now describe several variants of ShareBoost. The analysis we present in Section 5 can be easily adapted for these variants as well.

3.1 Modifying the Greedy Choice Rule

ShareBoost chooses the feature which maximizes the norm of the -th column of the gradient matrix. Our analysis shows that this choice leads to a sufficient decrease of the objective function. However, one can easily develop other ways for choosing a feature which may potentially lead to an even larger decrease of the objective. For example, we can choose a feature that minimizes over matrices with support of . This will lead to the maximal possible decrease of the objective function at the current iteration. Of course, the runtime of choosing will now be much larger. Some intermediate options are to choose that minimizes

or to choose that minimizes

where is the all-zero row vector except in the ’th position.

3.2 Selecting a Group of Features at a Time

In some situations, features can be divided into groups where the runtime of calculating a single feature in each group is almost the same as the runtime of calculating all features in the group. In such cases, it makes sense to choose groups of features at each iteration of ShareBoost. This can be easily done by simply choosing the group of features that maximizes .

3.3 Adding Regularization

Our analysis implies that when is significantly larger than then ShareBoost will not overfit. When this is not the case, we can incorporate regularization in the objective of ShareBoost in order to prevent overfitting. One simple way is to add to the objective function a Frobenius norm regularization term of the form , where is a regularization parameter. It is easy to verify that this is a smooth and convex function and therefore we can easily adapt ShareBoost to deal with this regularized objective. It is also possible to rely on other norms such as the norm or the mixed-norm. However, there is one technicality due to the fact that these norms are not smooth. We can overcome this problem by defining smooth approximations to these norms. The main idea is to first note that for a scalar we have and therefore we can rewrite the aforementioned norms using max and sum operations. Then, we can replace each max expression with its soft-max counterpart and obtain a smooth version of the overall norm function. For example, a smooth version of the norm will be where controls the tradeoff between quality of approximation and smoothness.

4 Non-Linear Prediction Rules

We now demonstrate how ShareBoost can be used for learning non-linear predictors. The main idea is similar to the approach taken by Boosting and SVM. That is, we construct a non-linear predictor by first mapping the original features into a higher dimensional space and then learning a linear predictor in that space, which corresponds to a non-linear predictor over the original feature space. To illustrate this idea we present two concrete mappings. The first is the decision stumps method which is widely used by Boosting algorithms. The second approach shows how to use ShareBoost for learning piece-wise linear predictors and is inspired by the super-vectors construction recently described in [41].

4.1 ShareBoost with Decision Stumps

Let be the original feature vector representing an object. A decision stump is a binary feature of the form , for some feature and threshold . To construct a non-linear predictor we can map each object into a feature-vector that contains all possible decision stumps. Naturally, the dimensionality of is very large (in fact, can even be infinite), and calculating Step 4 of ShareBoost may take forever. Luckily, a simple trick yields an efficient solution. First note that for each , all stump features corresponding to can get at most values on a training set of size . Therefore, if we sort the values of over the examples in the training set, we can calculate the value of the right-hand side of eqn. (7) for all possible values of in total time of . Thus, ShareBoost can be implemented efficiently with decision stumps.

Figure 1: Motivating super vectors.

4.2 Learning Piece-wise Linear Predictors with ShareBoost

To motivate our next construction let us consider first a simple one dimensional function estimation problem. Given sample

we would like to find a function such that for all . The class of piece-wise linear functions can be a good candidate for the approximation function . See for example an illustration in Fig. 1. In fact, it is easy to verify that all smooth functions can be approximated by piece-wise linear functions (see for example the discussion in [41]). In general, we can express piece-wise linear vector-valued functions as

where is the number of pieces, represents the linear function corresponding to piece , and represents the center and radius of piece . This expression can be also written as a linear function over a different domain, where

In the case of learning a multiclass predictor, we shall learn a predictor , where will be a by matrix. ShareBoost can be used for learning . Furthermore, we can apply the variant of ShareBoost described in Section 3.2

to learn a piece-wise linear model which few pieces (that is, each group of features will correspond to one piece of the model). In practice, we first define a large set of candidate centers by applying some clustering method to the training examples, and second we define a set of possible radiuses by taking values of quantiles from the training examples. Then, we train ShareBoost so as to choose a multiclass predictor that only use few pairs


The advantage of using ShareBoost here is that while it learns a non-linear model it will try to find a model with few linear “pieces”, which is advantageous both in terms of test runtime as well as in terms of generalization performance.

5 Analysis

In this section we provide formal guarantees for the ShareBoost algorithm. The proofs are deferred to the appendix. We first show that if the algorithm has managed to find a matrix with a small number of non-zero columns and a small training error, then the generalization error of is also small. The bound below is in terms of the loss. A related bound, which is given in terms of the convex loss function, is described in [40].

Theorem 1

Suppose that the ShareBoost algorithm runs for iterations and let

be its output matrix. Then, with probability of at least

over the choice of the training set we have that

Next, we analyze the sparsity guarantees of ShareBoost. As mentioned previously, exactly solving eqn. (4) is known to be NP hard. The following main theorem gives an interesting approximation guarantee. It tells us that if there exists an accurate solution with small norm, then the ShareBoost algorithm will find a good sparse solution.

Theorem 2

Let and let be an arbitrary matrix. Assume that we run the ShareBoost algorithm for iterations and let be the output matrix. Then, and .

6 Feature Sharing — Illustrative Examples

In this section we present illustrative examples, showing that whenever strong feature sharing is possible then ShareBoost will find it, while competitive methods might fail to produce solutions with a small number of features.

In the analysis of the examples below we use the following simple corollary of Theorem 2.

Corollary 1

Assume that there exists a matrix such that , all entries of are in , and . Then, ShareBoost will find a matrix with and .

The first example we present shows an exponential gap between the number of features required by ShareBoost (as well as mixed norms) and the number of features required by or regularization methods. Consider a set of examples such that each example, , is of the form , where is the binary representation of the number in the alphabet and is the vector which is zero everywhere except in the ’th coordinate. For example, if then , , , and .

Consider two matrices. The first matrix, denoted , is the matrix whose row equals to . The second matrix, denoted , is the matrix whose row equals to . Clearly, the number of features used by is while the number of features used by is .

Observe that both and (see definition in eqn. (1)), will make perfect predictions on the training set. Furthermore, since for each example , for each we have that , for the logistic multiclass loss, for any we have that

It follows that for

we have that .

Consider an algorithm that solves the regularized problem

where is either or . In both cases, we have that222 whereas . . It follows that for any value of , and for any , the value of the objective at is smaller than the value at . In fact, it is not hard to show that the optimal solution takes the form for some . Therefore, no matter what the regularization parameter is, the solution of the above regularized problem will use features, even though there exists a rather good solution that relies on shared features.

In contrast, using Corollary 1 we know that if we stop ShareBoost after iterations it will produce a matrix that uses only features and has a small loss. Similarly, it is possible to show that for an appropriate regularization parameter, the mix-norm regularization will also yield the matrix rather than the matrix .

In our second example we show that in some situations using the mix-norm regularization,

will also fail to produce a sparse solution, while ShareBoost is still guaranteed to learn a sparse solution. Let be an integer and consider examples where each is composed of blocks, each of which is in . We consider two types of examples. In the first type, each block of equals to . In the second type, we generate example as in the first type, but then we zero one of the blocks (where we choose uniformly at random which block to zero). As before, examples are of the first type while examples are of the second type.

Consider again two matrices. The first matrix, denoted , is the matrix whose row equals to . The second matrix, denoted , is the matrix whose row equals to . Note that . In addition, for any of the second type we have that , where expectation is with respect to the choice of which block to zero. Since the loss function is strictly convex, it follows from Jensen’s inequality that . We have thus shown that using the mix-norm as a regularization will prefer the matrix over . In fact, it is possible to show that the minimizer of will be of the form for some . Since the number of blocks, , was arbitrarily large, and since ShareBoost is guaranteed to learn a matrix with at most non-zero columns, we conclude that there can be a substantial gap between mix-norm regularization and ShareBoost. The advantage of ShareBoost in this example follows from its ability to break ties (even in an arbitrary way).

Naturally, the aforementioned examples are synthetic and capture extreme situations. However, in our experiments below we show that ShareBoost performs better than mixed-norm regularization on natural data sets as well.

7 Experiments

In this section we demonstrate the merits (and pitfalls) of ShareBoost by comparing it to alternative algorithms in different scenarios. The first experiment exemplifies the feature sharing property of ShareBoost. We perform experiments with an OCR data set and demonstrate a mild growth of the number of features as the number of classes grows from 2 to 36. The second experiment compares ShareBoost to mixed-norm regularization and to the JointBoost algorithm of [35]. We follow the same experimental setup as in [13]. The main finding is that ShareBoost outperforms the mixed-norm regularization method when the output predictor needs to be very sparse, while mixed-norm regularization can be better in the regime of rather dense predictors. We also show that ShareBoost is both faster and more accurate than JointBoost. The third and final set of experiments is on the MNIST handwritten digit dataset where we demonstrate state-of-the-art accuracy at extremely efficient runtime performance.

7.1 Feature Sharing

The main motivation for deriving the ShareBoost algorithm is the need for a multiclass predictor that uses only few features, and in particular, the number of features should increase slowly with the number of classes. To demonstrate this property of ShareBoost we experimented with the Char74k data set which consists of images of digits and letters. We trained ShareBoost with the number of classes varying from 2 classes to the 36 classes corresponding to the 10 digits and 26 capital letters. We calculated how many features were required to achieve a certain fixed accuracy as a function of the number of classes. The description of the feature space is described in Section 7.4.

Figure 2: The number of features required to achieve a fixed accuracy as a function of the number of classes for ShareBoost (dashed) and the 1-vs-rest (solid-circles). The blue lines are for a target error of 20% and the green lines are for 8%.

We compared ShareBoost to the 1-vs-rest approach, where in the latter, we trained each binary classifier using the same mechanism as used by ShareBoost. Namely, we minimize the binary logistic loss using a greedy algorithm. Both methods aim at constructing sparse predictors using the same greedy approach. The difference between the methods is that ShareBoost selects features in a shared manner while the 1-vs-rest approach selects features for each binary problem separately. In Fig. 2 we plot the overall number of features required by both methods to achieve a fixed accuracy on the test set as a function of the number of classes. As can be easily seen, the increase in the number of required features is mild for ShareBoost but significant for the 1-vs-rest approach.

7.2 Comparing ShareBoost to Mixed-Norms Regularization

Our next experiment compares ShareBoost to the use of mixed-norm regularization (see eqn. (5)) as a surrogate for the non-convex sparsity constraint. See Section 1.2 for description of the approach. To make the comparison fair, we followed the same experimental setup as in [13] (using code provided by ).

We calculated the whole regularization path for the mixed-norm regularization by running the algorithm of [13] with many values of the regularization parameter . In Fig. 3 we plot the results on three UCI datasets: StatLog, Pendigits and Isolet. The number of classes for the datasets are 7,10,26, respectively. The original dimensionality of these datasets is not very high and therefore, following [13]

, we expanded the features by taking all products over ordered pairs of features. After this transformation, the number of features were 630, 120, 190036, respectively.

Fig. 3 displays the results. As can be seen, ShareBoost decreases the error much faster than the mixed-norm regularization, and therefore is preferable when the goal is to have a rather sparse solution. When more features are allowed, ShareBoost starts to overfit. This is not surprising since here sparsity is our only mean for controlling the complexity of the learned classifier. To prevent this overfitting effect, one can use the variant of ShareBoost that incorporates regularization—see Section 3.

(a) StatLog (b) Pendigits (c) Isolet
Figure 3: ShareBoost compared with mixed-norm regularization (top) and JointBoost (bottom) on several UCI datasets. The horizontal axis is the feature sparsity (fraction of features used) and the vertical axis is the test error rate.

7.3 Comparing ShareBoost to JointBoost

Here we compare ShareBoost to the JointBoost algorithm of [35]. See Section 1.2 for description of JointBoost. As in the previous experiment, we followed the experimental setup as in [13] and ran JointBoost of [35] using their published code with additional implementation of the BFS heuristic for pruning the space of all class-subsets as described in their paper.

Fig. 3 (bottom) displays the results. Here we used stump features for both algorithms since these are needed for JointBoost. As can be seen, ShareBoost decreases the error much faster and therefore is preferable when the goal is to have a rather sparse solution. As in the previous experiment we observe that when more features are allowed, ShareBoost starts to overfit. Again, this is not surprising and can be prevented by adding additional regularization. The training runtime of ShareBoost is also much shorter than that of JointBoost (see discussion in Section 1.2).

Reference 3NN Shape Context SVM 9-poly Neural Net ShareBoost
Belongie-et-al DeCosta-et-al Ciresan-et-al
Error rate 2.7% 0.63% 0.56% 0.35% 0.47%
Errors 270 63 56 35 47
Year 2002 2002 2010 2011
Run time 14 1000’s 38 2.5 1
Table 1: Comparison of ShareBoost and relevant methods on error rate and computational complexity over the MNIST dataset. More details in the text.

7.4 MNIST Handwritten Digits Dataset

The goal of this experiment is to show that ShareBoost achieves state-of-the-art performance while constructing very fast predictors. We experimented with the MNIST digit dataset, which consists of a training set of digits represented by centered size-normalized images, and a test set of digits (see Fig. 6 for some examples). The MNIST dataset has been extensively studied and is considered the standard test for multiclass classification of handwritten digits. The error rate achieved by the most advanced algorithms are below of the test set (i.e., below classification mistakes on the test set). To get a sense of the challenge involved with the MNIST dataset, consider a straightforward 3-Nearest-Neighbor (3NN) approach where each test example , represented as a vector with entries, is matched against the entire training set using the distance . The classification decision is then the majority class label of the three most nearest training examples. This naive 3NN approach achieves an error rate of (i.e., mis-classification errors) with a run-time of unwieldy proportions. Going from 3NN to qNN with does not produce a better error rate.

More advanced shape-similarity measures could improve the performance of the naive approach but at a heavier run-time cost. For example, the Shape Context similarity measure introduced by [4] uses a Bipartite matching algorithm between descriptors computed along points in each image. A 3NN using Shape-Context similarity achieves an error rate of but at a very high (practically unwieldy) run-time cost. The challenge with the MNIST dataset is, therefore, to design a multiclass algorithm with a small error rate (say below ) and have an efficient run-time performance.

The top MNIST performer [7] uses a feed-forward Neural-Net with million connections which roughly translates to million multiply-accumulate (MAC) operations at run-time as well. During training, geometrically distorted versions of the original examples were generated in order to expand the training set following [31] who introduced a warping scheme for that purpose. The top performance error rate stands at at a run-time cost of million MAC per test example.

Table  1 summarizes the discussion so far including the performance of ShareBoost. The error-rate of ShareBoost with rounds stands on using the original training set and with the expanded training set of examples generated by adding five deformed instances per original example and with rounds. The run-time on test examples is around of the leading MNIST performer. The error rate of is better than that reported by [11] who used a 1-vs-all SVM with a 9-degree polynomial kernel and with an expanded training set of examples. The number of support vectors (accumulated over the ten separate binary classifiers) was giving rise to a run-time of -fold compared to ShareBoost. We describe below the details of the ShareBoost implementation on the MNIST dataset.

The feature space we designed consists of 77 image patches with corresponding spatial masks, constructed as follows. All 7

7 patches were collected from all images and clustered using K-means to produce

centers . For each such center (patch) we also associated a set of possible masks in order to limit the spatial locations of the maximal response of the patch. The pairs form the pool of templates (shape plus location). The vector of feature measurements has each of its entries associated with one of the templates where an entry . That is, a feature is the maximal response of the convolution of the template over the image, weighted by the Gaussian .

ShareBoost selects a subset of the templates where each represents some template pair , and the matrix . A test image is then converted to using with the maximum going over the image locations. The prediction is then . Fig. 5(a) shows the first 30 templates that were chosen by ShareBoost and their corresponding spatial masks. For example, the first templates matches a digit part along the top of the image, the eleventh template matches a horizontal stroke near the top of the image and so forth. Fig. 5(b) shows the weights (columns of ) of the first 30 templates of the model that produced the best results. For example, the eleventh template which encodes a horizontal line close to the top is expected in the digit “9” but not in the digit “4”. Fig. 6 shows the 47 misclassified samples after rounds of ShareBoost, and Fig. 4 displays the convergence curve of error-rate as a function of the number of rounds.

In terms of run-time on a test image, the system requires convolutions of templates and dot-product operations which totals to roughly MAC operations — compared to around MAC operations of the top MNIST performer. Moreover, due to the fast convergence of ShareBoost, 75 rounds are enough for achieving less than error. Further improvements of ShareBoost on the MNIST dataset are possible such as by extending further the training set using more deformations and by increasing the pool of features with other type of descriptors – but those were not pursued here. The point we desired to make is that ShareBoost can achieve competitive performance with the top MNIST performers, both in accuracy and in run-time, with little effort in feature space design while exhibiting great efficiency during training time as well.

Figure 4: Convergence of Shareboost on the MNIST dataset as it reaches 47 errors. The set was expanded with 5 deformed versions of each input, using the method in [31]. Since the deformations are fairly strong, the training error is higher than the test. Zoomed in version shown on the right.
(a) Leading 30 selected features (b) Corresponding columns of
Figure 5: (a) The first 30 selected features for the MNIST dataset. Each feature is composed of a 77 template and a position mask. (b) The corresponding columns of . The entries of a column represents the ”sharing” among classes pattern. For example, the eleventh template which encodes a horizontal line close to the top is expected in the digits “9,8,5” but not in digit “4”.
Figure 6: ShareBoost achieves an error of on the test set which translates to mistakes displayed above. Each error test example is displayed together with its predicted and True labels.

7.5 Comparing ShareBoost to kernel-based SVM

In the experiments on the MNIST data set reported above, each feature is the maximal response of the convolution of a patch over the image, weighted by a spatial mask.

One might wonder if the stellar performance of ShareBoost is maybe due to the patch-based features we designed. In this section we remove doubt by using ShareBoost for training a piece-wise linear predictor, as described in Section 4.2, on MNIST using generic features. We show that ShareBoost comes close to the error rate of SVM with Gaussian kernels, while only requiring anchor points, which is well below the number of support-vectors needed by kernel-SVM. This underscores the point that ShareBoost can find an extremely fast predictor without sacrificing state-of-the-art performance level.

Figure 7: Test accuracy of ShareBoost on the MNIST dataset as a function of the number of rounds using the generic piece-wise linear construction. Blue: train accuracy. Red: test accuracy. Dashed: SVM with Gaussian kernel accuracy.

Recall that the piece-wise linear predictor is of the following form:

where are anchor points with radius of influence , and define together a linear classifier for the ’th anchor. ShareBoost selects the set of anchor points and their radiuses together with the corresponding linear classifiers. In this context it is worthwhile to compare classification performance to SVM with Gaussian kernels applied in a 1-vs-all framework. Kernel-SVM also selects a subset of the training set with corresponding weight coefficients, thus from a mechanistic point of view our piece-wise linear predictor shares the same principles as kernel-SVM.

We performed a standard dimensionality reduction using PCA from the original raw pixel dimension of to , i.e., every digit was mapped to using PCA. The pool of anchor points was taken from a reduced training set by means of clustering into 1500 clusters and the range of radius values per anchor point was taken from a discrete set of 35 values. Taken together, each round of ShareBoost selected an anchor point and radius from a search space of size . Fig. 7 shows the error-rate per ShareBoost rounds. As can be seen, ShareBoost comes close to the error rate of SVM while only requiring anchor points, which is well below the number of support-vectors needed by kernel-SVM. This underscores the point that ShareBoost can find an extremely fast predictor without sacrificing state-of-the-art performance level.

8 Acknowledgements

We would like to thank Itay Erlich and Zohar Bar-Yehuda for their dedicated contribution to the implementation of ShareBoost.


  • Amit et al. [2007] Amit, Y., Fink, M., Srebro, N., and Ullman, S. Uncovering shared structures in multiclass classification. In International Conference on Machine Learning, 2007.
  • Argyriou et al. [2006] Argyriou, A., Evgeniou, T., and Pontil, M. Multi-task feature learning. In NIPS, pp. 41–48, 2006.
  • Bach [2008] Bach, F.R. Consistency of the group lasso and multiple kernel learning. J. of Machine Learning Research, 9:1179–1225, 2008.
  • Belongie et al. [2002] Belongie, S., Malik, J., and Puzicha, J. Shape matching and object recognition using shape contexts. IEEE PAMI, 24(4):509–522, April 2002.
  • Bengio et al. [2011] Bengio, S., Weston, J., and Grangier, D. Label embedding trees for large multi-class tasks. In NIPS, 2011.
  • Candes & Tao [2005] Candes, E.J. and Tao, T.

    Decoding by linear programming.

    IEEE Trans. on Information Theory, 51:4203–4215, 2005.
  • Ciresan et al. [2010] Ciresan, D. C., Meier, U., G., L. Maria, and Schmidhuber, J. Deep big simple neural nets excel on handwritten digit recognition. CoRR, 2010.
  • Crammer & Singer [2003] Crammer, K. and Singer, Y. Ultraconservative online algorithms for multiclass problems. Journal of Machine Learning Research, 3:951–991, 2003.
  • Daniely et al. [2011] Daniely, A., Sabato, S., Ben-David, S., and Shalev-Shwartz, S. Multiclass learnability and the erm principle. In COLT, 2011.
  • Davis et al. [1997] Davis, G., Mallat, S., and Avellaneda, M. Greedy adaptive approximation. Journal of Constructive Approximation, 13:57–98, 1997.
  • Decoste & Bernhard [2002] Decoste, D. and Bernhard, S. Training invariant support vector machines. Mach. Learn., 46:161–190, 2002.
  • Donoho [2006] Donoho, D.L. Compressed sensing. In Technical Report, Stanford University, 2006.
  • Duchi & Singer [2009] Duchi, J. and Singer, Y. Boosting with structural sparsity. In Proc. ICML, pp. 297–304, 2009.
  • Duda & Hart [1973] Duda, R. O. and Hart, P. E. Pattern Classification and Scene Analysis. Wiley, 1973.
  • Fink et al. [2006] Fink, M., Shalev-Shwartz, S., Singer, Y., and Ullman, S. Online multiclass learning by interclass hypothesis sharing. In International Conference on Machine Learning, 2006.
  • Freund & Schapire [1999] Freund, Y. and Schapire, R. E. A short introduction to boosting. J. of Japanese Society for AI, pp. 771–780, 1999.
  • Freund & Schapire [1997] Freund, Y. and Schapire, R.E. A decision-theoretic generalization of on-line learning and an application to boosting. Journal of Computer and System Sciences, pp. 119–139, 1997.
  • Hastie & Tibshirani [1995] Hastie, T.J. and Tibshirani, R.J. Generalized additive models. Chapman & Hall, 1995.
  • Hsu et al. [2010] Hsu, D., Kakade, S.M., Langford, J., and Zhang, T. Multi-label prediction via compressed sensing. In NIPS, 2010.
  • Huang & Zhang [2010] Huang, J. and Zhang, T. The benefit of group sparsity. Annals of Statistics, 38(4), 2010.
  • Huang et al. [2009] Huang, J., Zhang, T., and Metaxas, D.N. Learning with structured sparsity. In ICML, 2009.
  • Lanckriet et al. [2004] Lanckriet, G.R.G., Cristianini, N., Bartlett, P.L., Ghaoui, L. El, and Jordan, M.I. Learning the kernel matrix with semidefinite programming. J. of Machine Learning Research, pp. 27–72, 2004.
  • LeCun et al. [1998] LeCun, Y. L., Bottou, L., Bengio, Y., and Haffner, P. Gradient-based learning applied to document recognition. Proceedings of IEEE, pp. 2278–2324, 1998.
  • Majumdar & Ward [2009] Majumdar, A. and Ward, R.K. Fast group sparse classification. Electrical and Computer Engineering, Canadian Journal of, 34(4):136–144, 2009.
  • Natarajan [1995] Natarajan, B. Sparse approximate solutions to linear systems. SIAM J. Computing, pp. 227–234, 1995.
  • Nesterov & Nesterov [2004] Nesterov, Y. and Nesterov, I.U.E. Introductory lectures on convex optimization: A basic course, volume 87. Springer Netherlands, 2004.
  • Quattoni et al. [2008] Quattoni, A., Collins, M., and Darrell, T. Transfer learning for image classification with sparse prototype representations. In CVPR, 2008.
  • Quattoni et al. [2009] Quattoni, A., Carreras, X., Collins, M., and Darrell, T. An efficient projection for l , regularization. In ICML, pp. 108, 2009.
  • Schapire & Singer [1999] Schapire, R. E. and Singer, Y. Improved boosting algorithms using confidence-rated predictions. Machine Learning, 37(3):1–40, 1999.
  • Shalev-Shwartz et al. [2010] Shalev-Shwartz, S., Zhang, T., and Srebro, N. Trading accuracy for sparsity in optimization problems with sparsity constraints. Siam Journal on Optimization, 20:2807–2832, 2010.
  • Simard et al. [2003] Simard, P. Y., S., Dave, and Platt, John C.

    Best practices for convolutional neural networks applied to visual document analysis.

    Document Analysis and Recognition, 2003.
  • Taskar et al. [2003] Taskar, B., Guestrin, C., and Koller, D. Max-margin markov networks. In NIPS, 2003.
  • Thrun [1996] Thrun, S. Learning to learn: Introduction. Kluwer Academic Publishers, 1996.
  • Tibshirani [1996] Tibshirani, R. Regression shrinkage and selection via the lasso. J. Royal. Statist. Soc B., 58(1):267–288, 1996.
  • Torralba et al. [2007] Torralba, A., Murphy, K. P., and Freeman, W. T. Sharing visual features for multiclass and multiview object detection. IEEE Transactions on Pattern Analysis and Machine Intelligence (PAMI), pp. 854–869, 2007.
  • Tropp & Gilbert [2007] Tropp, J.A. and Gilbert, A.C. Signal recovery from random measurements via orthogonal matching pursuit. Information Theory, IEEE Transactions on, 53(12):4655–4666, 2007.
  • Turlach et al. [2000] Turlach, B. A, V., W. N, and Wright, Stephen J. Simultaneous variable selection. Technometrics, 47, 2000.
  • Vapnik [1998] Vapnik, V. N. Statistical Learning Theory. Wiley, 1998.
  • Xing et al. [2003] Xing, E., Ng, A.Y., Jordan, M., and Russell, S. Distance metric learning, with application to clustering with side-information. In NIPS, 2003.
  • Zhang [2004] Zhang, T. Class-size independent generalization analysis of some discriminative multi-category classification. In NIPS, 2004.
  • Zhou et al. [2010] Zhou, X., Yu, K., Zhang, T., and Huang, T. Image classification using super-vector coding of local image descriptors. Computer Vision–ECCV 2010, pp. 141–154, 2010.

Appendix A Proofs

a.1 Proof of Theorem 1

The proof is based on an analysis of the Natarajan dimension of the class of matrices with small number of non-zero columns. The Natarajan dimension is a generalization of the VC dimension for classes of multiclass hypotheses. In particular, we rely on the analysis given in Theorem 25 and Equation 6 of [9]. This implies that if the set of columns of are chosen in advance then

Applying the union bound over all options to choose the relevant features we conclude our proof.

a.2 Proof of Theorem 2

To prove the theorem, we start by establishing a certain smoothness property of . First, we need the following.

Lemma 1

. Let be defined as

Then, for any we have

Proof  Using Taylor’s theorem, it suffices to show that the Hessian of at any point satisfies

Consider some vector and without loss of generality assume that . We have,

and for

Note that , and that for , . Let be the Hessian of at . It follows that for ,

In addition, for where both and are not we have

For we have

and for

We can therefore rewrite as

It thus follows that:

where the last step is because for any , the function receives its maximum when and then its value is . This concludes our proof.  

The above lemma implies that is smooth in the following sense:

Lemma 2

For any s.t. (that is, only the ’th column of is not zero) we have that

Proof  Recall that is the average over of a function of the form , where is as defined in Lemma 1. Therefore,

where the last inequality is because we assume that for all . The above implies that



Equipped with the smoothness property of , we now turn to show that if the greedy algorithm has not yet identified all the features of then a single greedy iteration yields a substantial progress. We use the notation to denote the indices of columns of which are not all-zeros.

Lemma 3

Let be two subsets of such that and let

Then, if we have

where .

Proof  To simplify notation, denote . Using Lemma 2 we know that for any :

In particular, the above holds for the vector of and by rearranging we obtain that

It is therefore suffices to show that

Denote , then an equivalent inequality333This is indeed equivalent because the lemma assumes that is

From the convexity of , the right-hand side of the above is upper bounded by . Hence, it is left to show that

Since we assume that is optimal over we get that for all , hence . Additionally, for . Therefore,

and this concludes our proof.  

Using the above lemma, the proof of our main theorem easily follows.

Proof [of Theorem 2] Denote , where is the value of at iteration . The definition of the update implies that . The conditions of Lemma 3 hold and therefore we obtain that (with )