11 Making Large-Scale SVM Learning Practical

Thorsten Joachims
Universitat Dortmund, Informatik, AI-Unit
Thorsten Joachims@[Link]
[Link]
To be published in: 'Advances in Kernel Methods - Support Vector Learning',
Bernhard Scholkopf, Christopher J. C. Burges, and Alexander J. Smola (eds.),
MIT Press, Cambridge, USA, 1998.
Training a support vector machine (SVM) leads to a quadratic optimization
problem with bound constraints and one linear equality constraint. Despite the
fact that this type of problem is well understood, there are many issues to be
considered in designing an SVM learner. In particular, for large learning tasks with
many training examples, o-the-shelf optimization techniques for general quadratic
programs quickly become intractable in their memory and time requirements.
SV M light 1 is an implementation of an SVM learner which addresses the problem of
large tasks. This chapter presents algorithmic and computational results developed
for SV M light V2.0, which make large-scale SVM training more practical. The results
give guidelines for the application of SVMs to large domains.

11.1 Introduction
Chapter 1 and Vapnik (1995) show how training a support vector machine for the
pattern recognition problem leads to the following quadratic optimization problem
(QP) OP1.
X̀ X̀ X̀
(OP1) minimize: W () = , i + 21 yi yj ij k(xi ; xj ) (11.1)
i=1 i=1 j =1
X̀
subject to: yi i = 0 (11.2)
i=1
8i : 0  i  C (11.3)

1. SV M lightis available at [Link] light

Generic author design sample pages 1998/07/09 14:59

 42 Making Large-Scale SVM Learning Practical

The number of training examples is denoted by `.  is a vector of ` variables,

where each component i corresponds to a training example (xi ; yi). The solution
of OP1 is the vector  for which (11.1) is minimized and the constraints (11.2)
and (11.3) are fullled. Dening the matrix Q as (Q)ij = yi yj k(xi ; xj ), this can
equivalently be written as
minimize: W () = ,T 1 + 21 T Q (11.4)

subject to: T y = 0 (11.5)

0    C1 (11.6)

The size of the optimization problem depends on the number of training examples
`. Since the size of the matrix Q is `2 , for learning tasks with 10000 training
examples and more it becomes impossible to keep Q in memory. Many standard
implementations of QP solvers require explicit storage of Q which prohibits their
application. An alternative would be to recompute Q every time it is needed. But
this becomes prohibitively expensive, if Q is needed often.
One approach to making the training of SVMs on problems with many training
examples tractable is to decompose the problem into a series of smaller tasks.
SV M light uses the decomposition idea of Osuna et al. (1997b). This decomposition
splits OP1 in an inactive and an active part - the so call \working set". The
main advantage of this decomposition is that it suggests algorithms with memory
requirements linear in the number of training examples and linear in the number of
SVs. One potential disadvantage is that these algorithms may need a long training
time. To tackle this problem, this chapter proposes an algorithm which incorporates
the following ideas:
An ecient and eective method for selecting the working set.
Successive \shrinking" of the optimization problem. This exploits the property
that many SVM learning problems have
much less support vectors (SVs) than training examples.
many SVs which have an i at the upper bound C .
Computational improvements like caching and incremental updates of the gradi-
ent and the termination criteria.
This chapter is structured as follows. First, a generalized version of the decom-
positon algorithm of Osuna et al. (1997a) is introduced. This identies the problem
of selecting the working set, which is addressed in the following section. In sec-
tion 11.4 a method for \shrinking" OP1 is presented and section 11.5 describes the
computational and implementational approach of SV M light . Finally, experimental
results on two benchmark tasks, a text classication task, and an image recognition
task are discussed to evaluate the approach.

Generic author design sample pages 1998/07/09 14:59

 11.2 General Decomposition Algorithm 43

11.2 General Decomposition Algorithm

This section presents a generalized version of the decomposition strategy proposed
by Osuna et al. (1997a). This strategy uses a decomposition similar to those used in
active set strategies (see Gill et al. (1981)) for the case that all inequality constraints
are simple bounds. In each iteration the variables i of OP1 are split into two
categories.
the set B of free variables
the set N of xed variables
Free variables are those which can be updated in the current iteration, whereas
xed variables are temporarily xed at a particular value. The set of free variables
will also be referred to as the working set. The working set has a constant size q
much smaller than `.
The algorithm works as follows:
While the optimality conditions are violated
Select q B
variables for the working set . The remaining
`,q variables are fixed at their current value.
Decompose problem and solve QP-subproblem: optimize W () on B.
Terminate and return .
Optimality Con- How can the algorithm detect that it has found the optimal value for ? Since
ditions OP1 is guaranteed to have a positive-semidenite Hessian Q and all constraints
are linear, OP1 is a convex optimization problem. For this class of problems
the following Kuhn-Tucker conditions are necessary and sucient conditions for
optimality. Denoting the Lagrange multiplier for the equality constraint 11.5 with
eq and the Lagrange multipliers for the lower and upper bounds 11.6 with lo and
up ,  is optimal for OP1, if there exist eq , lo , and up , so that (Kuhn-Tucker
Conditions, see Werner (1984)):

g() + (eq y , lo + up )= 0 (11.7)

8i 2 [1::n] : loi (,i) =0 (11.8)

8i 2 [1::n] : up
i (i , C ) =0 (11.9)

 lo 0 (11.10)

 up 0 (11.11)

yT =0 (11.12)

0   C1 (11.13)

g() is the vector of partial derivatives at . For OP1 this is

g() = ,1 + Q (11.14)

Generic author design sample pages 1998/07/09 14:59

 44 Making Large-Scale SVM Learning Practical

QP-Subproblems If the optimality conditions do not hold, the algorithm decomposes OP1 and
solves the smaller QP-problem arising from this. The decomposition assures that
this will lead to progress in the objective function W (), if the working set B
fullls some minimum requirements (see Osuna et al. (1997b)). In particular, OP1
is decomposed by separating the variables in the working set B from those which
are xed (N ). Let's assume , y, and Q are properly arranged with respect to B
and N , so that
     
 =   B 
  y
y =   B  Q =  QBB Q BN 
N  yN QNB QNN 
(11.15)

Since Q is symmetric (in particular QBN = QTNB ), we can write

(OP2) minimize: W () = ,TB (1 , QBN N ) + 21 TB QBB B +
1 T T
2 N QNN N , N 1 (11.16)

subject to: TB yB + TN yN = 0 (11.17)

0    C1 (11.18)

Since the variables in N are xed, the terms 12 TN QNN N and ,TN 1 are
constant. They can be omitted without changing the solution of OP2. OP2 is a
positive semidenite quadratic programming problem which is small enough be
solved by most o-the-shelf methods. It is easy to see that changing the i in
the working set to the solution of OP2 is the optimal step on B . So fast progress
depends heavily on whether the algorithm can select good working sets.

11.3 Selecting a Good Working Set

When selecting the working set, it is desirable to select a set of variables such
that the current iteration will make much progress towards the minimum of W ().
The following proposes a strategy based on Zoutendijk's method (see Zoutendijk
(1970)), which uses a rst-order approximation to the target function. The idea is to
nd a steepest feasible direction d of descent which has only q non-zero elements.
The variables corresponding to these elements will compose the current working
set.
This approach leads to the following optimization problem:
(OP3) minimize: V (d) = g((t))T d (11.19)

subject to: T
y d=0 (11.20)

di  0 for i: i = 0 (11.21)

di  0 for i: i = C (11.22)

,1 d 1 (11.23)

jfdi : di 6= 0gj = q (11.24)

Generic author design sample pages 1998/07/09 14:59

 11.4 Shrinking: Reducing the Size of OP1 45

The objective (11.19) states that a direction of descent is wanted. A direction

of descent has a negative dot-product with the vector of partial derivatives g((t) )
at the current point (t). Constraints (11.20), (11.21), and (11.22) ensure that the
direction of descent is projected along the equality constraint (11.5) and obeys the
active bound constraints. Constraint (11.23) normalizes the descent vector to make
the optimization problem well-posed. Finally, the last constraint (11.24) states that
the direction of descent shall only involve q variables. The variables with non-zero
di are included into the working set B . This way we select the working set with the
steepest feasible direction of descent.
11.3.1 Convergence
The selection strategy, the optimality conditions, and the decomposition together
specify the optimization algorithm. A minimum requirement this algorithm has to
fulll is that it
terminates only when the optimal solution is found
if not at the solution, takes a step towards the optimum
The rst requirement can easily be fullled by checking the (necessary and
sucient) optimality conditions (11.7) to (11.13) in each iteration. For the second
one, let's assume the current (t) is not optimal. Then the selection strategy for the
working set returns an optimization problem of type OP2. Since by construction for
this optimization problem there exists a d which is a feasible direction for descent,
we know using the results of Zoutendijk (1970) that the current OP2 is non-optimal.
So optimizing OP2 will lead to a lower value of the objective function of OP2. Since
the solution of OP2 is also feasible for OP1 and due to the decomposition (11.16),
we also get a lower value for OP1. This means we get a strict descent in the objective
function of OP1 in each iteration.
11.3.2 How to Solve OP3
The solution to OP3 is easy to compute using a simple strategy. Let !i = yi gi((t) )
and sort all i according to !i in decreasing order. Let's futhermore require that
q is an even number. Successively pick the q=2 elements from the top of the list
for which 0 < (it) < C , or di = ,yi obeys (11.21) and (11.22). Similarly, pick the
q=2 elements from the bottom of the list for which 0 < (it) < C , or di = yi obeys
(11.21) and (11.22). These q variables compose the working set.

11.4 Shrinking: Reducing the Size of OP1

For many tasks the number of SVs is much smaller than the number of training
examples. If it was known a priori which of the training examples turn out as SVs,

Generic author design sample pages 1998/07/09 14:59

 46 Making Large-Scale SVM Learning Practical

it would be sucient to train just on those examples and still get to the same result.
This would make OP1 smaller and faster to solve, since we could save time and
space by not needing parts of the Hessian Q which do not correspond to SVs.
Similarly, for noisy problems there are often many SVs with an i at the upper
bound C . Let's call these support vectors \bounded support vectors" (BSVs).
Similar arguments as for the non-support vectors apply to BSVs. If it was known a
priori which of the training examples turn out as BSVs, the corresponding i could
be xed at C leading to a new optimization problem with fewer variables.
During the optimization process it often becomes clear fairly early that certain
examples are unlikely to end up as SVs or that they will be BSVs. By eliminating
these variables from OP1, we get a smaller problem OP1' of size `0 . From OP1' we
can construct the solution of OP1. Let X denote those indices corresponding to
unbounded support vectors, Y those indexes which correspond to BSVs, and Z the
indices of non-support vectors. The transformation from OP1 to OP1' can be done
using a decomposition similar to (11.16). Let's assume , y, and Q are properly
arranged with respect to X , Y , and Z , so that we can write
       
 X   X   yX   QXX QXY QXZ 
 =  Y  =  C 1  y =  yY  Q =  QY X QY Y QY Z  (11.25)
 Z   0   yZ   QZX QZY QZZ 
The decomposition of W () is
minimize: W (X ) = ,TX (1 , (QXY 1)
C ) + 21 TX QXX X +
1 C 1T Q C 1 , jY jC
2 YY (11.26)

subject to: TX yX + C 1T yY = 0 (11.27)

0  X  C 1 (11.28)

Since 12 C 1T QY Y C 1 , jY jC is constant, it can be dropped without changing the

solution. So far it is not clear how the algorithm can identify which examples can be
eliminated. It is desirable to nd conditions which indicate early in the optimization
process that certain variables will end up at a bound. Since sucient conditions are
not known, a heuristic approach based on Lagrange multiplier estimates is used.
At the solution, the Lagrange multiplier of a bound constraint indicates, how
much the variable \pushes" against that constraint. A strictly positive value of a
Lagrange multiplier of a bound constraint indicates that the variable is optimal at
that bound. At non-optimal points, an estimate of the Lagrange multiplier can be
used. Let A be the current set of i fullling 0 < i < C . By solving (11.7) for eq
and averaging over all i in A, we get the estimate (11.29) for eq .
2 3
X X̀
eq = jA1 j 4yi , j yj k(xi ; xj)5 (11.29)
i2A j =1
Note the equivalence of eq and b in (11.41). Since variables i cannot be both at the

Generic author design sample pages 1998/07/09 14:59

 11.5 Ecient Implementation 47

upper and the lower bound simultanously, the multipliers of the bound constraints
can now be estimated by
02 3 1
X̀
loi = yi @4 j yj k(xi ; xj)5 + eq A , 1 (11.30)
j =1
for the lower bounds and by
02 3 1
X̀
i = ,yi @4 j yj k(xi ; xj)5 +  A + 1
up eq (11.31)
j =1
for the upper bounds. Let's consider the history of the Lagrange multiplier estimates
over the last h iterations. If the estimate (11.30) or (11.31) was positive (or above
some threshold) at each of the last h iterations, it is likely that this will be true at
the optimal solution, too. These variables are eliminated using the decomposition
from above. This means that these variables are xed and neither the gradient, nor
the optimality conditions are computed. This leads to a substantial reduction in
the number of kernel evaluations.
Since this heuristic can fail, the optimality conditions for the excluded variables
are checked after convergence of OP1'. If necessary, the full problem is reoptimized
starting from the solution of OP1'.

11.5 Ecient Implementation

While the previous sections dealt with algorithmic issues, there are still a lot of open
questions to be answered before having an ecient implementation. This section
addresses these implementational issues.
11.5.1 Termination Criteria
There are two obvious ways to dene termination criteria which t nicely into the
algorithmic framework presented above. First, the solution of OP3 can be used to
dene a necessary and sucient condition for optimality. If (11.19) equals 0, OP1
is solved with the current (t) as solution.
SV M light goes another way and uses a termination criterion derived from the
optimality conditions (11.7)-(11.13). Using the same reasoning as for (11.29)-
(11.31), the following conditions with  = 0 are equivalent to (11.7)-(11.13).
8i with 0 < i < C : eq ,   yi , [P`j =1 j yj k(xi ; xj)]  eq +  (11.32)
P `
8i with i = 0: yi ([ j =1 j yj k(xi ; xj)] +  )  1 , 
eq (11.33)
P `
8i with i = C : yi ([ j =1 j yj k(xi ; xj)] + eq )  1 +  (11.34)

 y=0
T (11.35)

The optimality conditions (11.32), (11.33), and (11.34) are very natural since

Generic author design sample pages 1998/07/09 14:59

 48 Making Large-Scale SVM Learning Practical

they re ect the constraints of the original optimization problem (11.40). In practice
these conditions need not be fullled with high accuracy. Using a tolerance of
 = 0:001 is acceptable for most tasks. Using a higher accuracy did not show
improved generalization performance on the tasks tried, but lead to considerably
longer training time.
11.5.2 Computing the Gradient and the Termination Criteria Eciently
The eciency of the optimization algorithm greatly depends on how eciently the
\housekeeping" in each iteration can be done. The following quantities are needed
in each iteration.
The vector of partial derivatives g((t) ) for selecting the working set.
The values of the expressions (11.32), (11.33), and (11.34) for the termination
criterion.
The matrices QBB and QBN for the QP subproblem.
Fortunately, due to the decompositon approach, all these quantities can be com-
puted or updated knowing only q rows of the Hessian Q. These q rows correspond to
the variables in the current working set. The values in these rows are computed di-
rectly after the working set is selected and they are stored throughout the iteration.
It is useful to introduce s(t)
X̀
s(it) = j yj k(xi ; xj) (11.36)
j =1
Knowing s(t), the gradient (11.14) as well as in the termination criteria (11.32)-
(11.34) can be computed very eciently. When (t,1) changes to (t) the vector
s(t) needs to be updated. This can be done eciently and with sucient accuracy
as follows
X
s(it) = s(it,1) + ((jt) , (jt,1))yj k(xi ; xj ) (11.37)
j 2B
Note that only those rows of Q are needed which correspond to variables in the
working set. The same is true for QBB and QBN , which are merely subsets of
columns from these rows.
11.5.3 What are the Computational Resources Needed in each Iteration?
Time Complexity Most time in each iteration is spent on the kernel evaluations needed to compute
the q rows of the Hessian. This step has a time complexity of O(qlf ), where f is the
maximum number of non-zero features in any of the training examples. Using the
stored rows of Q, updating s(t) is done in time O(ql). Setting up the QP subproblem
requires O(ql) as well. Also the selection of the next working set, which includes
computing the gradient, can be done in O(ql).

Generic author design sample pages 1998/07/09 14:59

 11.6 Related Work 49

Space Complexity The highest memory requirements are due to storing the q rows of Q. Here O(ql)
oating point numbers need to be stored. Besides this, O(q2 ) is needed to store
QBB and O(l) to store s(t).
11.5.4 Caching Kernel Evaluations
As pointed out in the last section, the most expensive step in each iteration is
the evaluation of the kernel to compute the q rows of the Hessian Q. Throughout
the optimization process, eventual support vectors enter the working set multiple
times. To avoid recomputation of these rows, SV M light uses caching. This allows
an elegant trade-o between memory consumption and training time.
SV M light uses a least-recently-used caching strategy. When the cache is full, the
element which has not been used for the greatest number of iterations, is removed
to make room for the current row.
Only those columns are computed and cached which correspond to active vari-
ables. After shrinking, the cache is reorganized accordingly.
11.5.5 How to Solve OP2 (QP Subproblems)
Currently a primal-dual interior-point solver (see Vanderbei (1994)) implemented
by A. Smola is used to solve the QP subproblems OP2. Nevertheless, other opti-
mizers can easily be incorporated into SV M light as well.

11.6 Related Work

The rst approach to splitting large SVM learning problems into a series of
smaller optimization tasks was proposed by Boser et al. (1992). It is known as the
\chunking" algorithm (see also chapter 10). The algorithm starts with a random
subset of the data, solves this problem, and iteratively adds examples which violate
the optimality conditions. Osuna et al. (1997b) prove formally that this strategy
converges to the optimal solution. One disadvantage of this algorithm is that it is
necessary to solve QP-problems scaling with the number of SVs. The decomposition
of Osuna et al. (1997a), which is used in the algorithm presented here, avoids this.
Currently, an approach called Sequential Minimal Optimization (SMO) is ex-
plored for SVM training (see Platt (1998) and chapter ??). It can be seen a special
case of the algorithm presented in this chapter, allowing only working sets of size
2. The algorithms dier in their working set selection strategies. Instead of the
steepest feasible descent approach presented here, SMO uses a set of heuristics.
Nevertheless, these heuristics are likely to produce similar decisions in practice.
Another dierence is that SMO treats linear SVMs in a special way, which pro-
duces a great speedup for training linear separators. Although possible, this is not
implemented in SV M light . On the other hand, SV M light uses caching, which could
be a valuable addition to SMO.

Generic author design sample pages 1998/07/09 14:59

 50 Making Large-Scale SVM Learning Practical

11.7 Experiments
The following experiments evaluate the approach on four datasets. The experiments
are conducted on a SPARC Ultra/167Mhz with 128MB of RAM running Solaris II.
If not stated otherwise, in the following experiments the cache size is 80 megabytes,
the number of iterations h for the shrinking heuristic is 100, and OP1 is solved up
to a precision of  = 0:001 in (11.32)-(11.34).
11.7.1 How does Training Time Scale with the Number of Training
Examples?
[Link] Income Prediction
This task was compiled by John Platt (see Platt (1998)) from the UCI \adult" data
set. The goal is to predict whether a household has an income greater than $50,000.
After discretization of the continuous attributes, there are 123 binary features. On
average, there are 14 non-zero attributes per example.
Table 11.1 and the left graph in gure 11.1 show training times for an RBF-kernel
(11.38) with  = 10 and C = 1. The results for SMO and Chunking are taken from
Platt (1998). When comparing absolute training times, one should keep in mind
that SMO and Chunking were run on a faster computer (266Mhz Pentium II)2 .

Examples SV M light SMO Chunking Minimum total SV BSV

1605 7.8 15.8 34.8 4.2 691 585
2265 16.8 32.1 144.7 9.0 1007 849
3185 30.6 66.2 380.5 6.8 1293 1115
4781 68.4 146.6 1137.2 38.4 1882 1654
6414 120.6 258.8 2530.6 70.2 2475 2184
11221 430.8 781.4 11910.6 215.4 4182 3763
16101 906.0 1784.4 N/A 436.2 5894 5398
22697 1845.6 4126.4 N/A 862.8 8263 7574
32562 3850.2 7749.6 N/A 1795.8 11572 10740
Scaling 2.1 2.1 2.9 2.0
Table 11.1 Training times and number of SVs for the income prediction data.

Both SV M light and SMO are substantially faster than the conventional chunking
algorithm, whereas SV M light is about twice as fast as SMO. The best working set
size is q = 2. By tting lines to the log-log plot we get an empirical scaling of `2:1
for both SV M light and SMO. The scaling of the chunking algorithm is `2:9 .
The column \minimum" gives a lower bound on the training time. This bound
makes the conjecture that in the general case any optimization algorithms needs to

Generic author design sample pages 1998/07/09 14:59

 11.7 Experiments 51
8000 4000

chunking chunking
SMO SMO
7000 SVM-Light 3500 SVM-Light
minimum minimum

6000 3000

CPU-time in seconds

CPU-time in seconds
5000 2500

4000 2000

3000 1500

2000 1000

1000 500

0 0
0 5000 10000 15000 20000 25000 30000 35000 0 5000 10000 15000 20000 25000 30000 35000 40000 45000 50000
Number of examples Number of examples

Figure 11.1 Training times from tables 11.1 (left) and 11.2 (right) as graphs.

at least once look at the rows of the Hessian Q which correspond to the support
vectors. The column \minimum" shows the time to compute those rows once
(exploiting symmetry). This time scales with `2:0, showing the complexity inherent
in the classication task. For the training set sizes considered, SV M light is both
close to this minimum scaling as well as within a factor of approximately two in
terms of absolute runtime.
[Link] Classifying Web Pages
The second data set - again compiled by John Platt (see Platt (1998)) - is a text
classication problem with a binary representation based on 300 keyword features.
This representation is extremely sparse. On average there are only 12 non-zero
features per example.

Examples SV M light SMO Chunking Minimum total SV BSV

2477 18.0 26.3 64.9 3.6 431 47
3470 28.2 44.1 110.4 7.8 571 69
4912 46.2 83.6 372.5 13.2 671 96
7366 102.0 156.7 545.4 27.0 878 138
9888 174.6 248.1 907.6 46.8 1075 187
17188 450.0 581.0 3317.9 123.6 1611 363
24692 843.0 1214.0 6659.7 222.6 1994 506
49749 2834.4 3863.5 23877.6 706.2 3069 948
Scaling 1.7 1.7 2.0 1.7
Table 11.2 Training times and number of SVs for the Web data.

Table 11.2 shows training times on this data set for an RBF-kernel (11.38) with
 = 10 and C = 5. Again, the times for SMO and Chunking are taken from Platt
(1998). SV M light is faster than SMO and Chunking on this data set as well, scaling
with `1:7. The best working set size is q = 2.

Generic author design sample pages 1998/07/09 14:59

 52 Making Large-Scale SVM Learning Practical

[Link] Ohsumed Data Set

The task in this section is a text classication problem which uses a dierent rep-
resentation. Support vector machines have shown very good generalisation perfor-
mance using this representation (see Joachims (1998)). Documents are represented
as high dimensional vectors, where each dimension contains a (TFIDF-scaled) count
of how often a particular word occurs in the document. More details can be found
in Joachims (1998). The particular task is to learn \Cardiovascular Diseases" cat-
egory of the Ohsumed dataset. It involves the rst 46160 documents from 1991
using 15000 features. On average, there are 63 non-zero features per example. An
RBF-kernel with  = 0:91 and C = 50 is used.

Examples SV M light Minimum total SV BSV

9337 18.8 7.1 4037 0
13835 46.3 14.4 5382 0
27774 185.7 50.8 9018 0
46160 509.5 132.7 13813 0
Scaling 2.0 1.8
Table 11.3 Training time (in minutes) and number of SVs for the Ohsumed data.

Table 11.3 shows that this tasks involves many SVs which are not at the upper
bound. Relative to this high number of SVs the cache size is small. To avoid
frequent recomputations of the same part of the Hessian Q, an additional heuristic
is incorporated here. The working set is selected with the constraint that at least
for half of the selected variables the kernel values are already cached. Unlike for the
previous tasks, optimum performance is achieved with a working set size of q = 20.
For the training set sizes considered here, runtime is within a factor of 4 from the
minimum.
[Link] Dectecting Faces in Images
In this last problem the task is to classify images according to whether they contain
a human face or not. The data set was collected by Shumeet Baluja. The images
consist of 20x20 pixels of continuous gray values. So the average number of non-zero
attributes per example is 400. An RBF-kernel with  = 7:1 and C = 10 is used.
The working set size is q = 20.
Table 11.4 shows the training time (in seconds). For this task, the training time
is very close to the minimum. This shows that the working set selection strategy
is very well suited for avoiding unnecessary kernel evaluations. The scaling is very
close to the optimum scaling.
Let's now evaluate, how particular strategies of the algorithm in uence the
performance.

Generic author design sample pages 1998/07/09 14:59

 11.7 Experiments 53

Examples SV M light Minimum total SV BSV

512 10.8 8.4 340 0
1025 37.2 31.2 559 0
2050 129.0 111.0 930 0
4100 443.4 381.0 1507 0
8200 1399.2 1170.6 2181 0
Scaling 1.7 1.7
Table 11.4 Training time and number of SVs for the face detection data.

90 45

80 40

70 35

60 30
CPU-time in minutes

CPU-time in minutes
50 25

40 20

30 15

20 10

10 5

0 0
0 10 20 30 40 50 60 70 80 90 100 0 10 20 30 40 50 60 70 80
Size of working set Cache-size in MB

Figure 11.2 Training time dependent on working set size and cache size for the
Ohsumed task.
11.7.2 What is the In uence of the Working Set Selection Strategy?
Working Set Se- The left of gure 11.2 shows training time dependent on the size of the working set
lection q for the smallest Ohsumed task. The selection strategy from section 11.3 (lower
curve) is compared to a basic strategy similar to that proposed in Osuna et al.
(1996) (upper curve). In each iteration the basic strategy simply replaces half of
the working set with variables that do not fulll the optimality conditions. The
graph shows that the new selection strategy reduces time by a factor of more than
3.
11.7.3 What is the In uence of Caching?
Caching The curves in the graph on the right hand side of gure 11.2 shows that caching
has a strong impact on training time. The lower curve shows training time (for an
RBF-kernel with  = 10 and C = 50 on the 9337 examples of the Ohsumed data)
dependent on the cache size when shrinking is used. With the cache size ranging
from 2 megabytes to 80 megabytes a speedup factor of 2.8 is achieved. The speedup
generally increases with an increasing density of the feature vectors xi .

Generic author design sample pages 1998/07/09 14:59

 54 Making Large-Scale SVM Learning Practical

11.7.4 What is the In uence of Shrinking?

Shrinking All experiments above use the shrinking strategy from section 11.4. The upper curve
in gure 11.2 (right) shows training time without shrinking. It can be seen that
shrinking leads to a substantial improvement when the cache is small in relation
to the size of the problem. The gain generally increases the smaller the fraction
of unbounded SVs is compared to the number of training examples ` (here 2385
unbounded SVs, 110 BSVs, and a total of 9337 examples).

11.8 Conclusions
This chaper presents an improved algorithm for training SVMs on large-scale prob-
lems and describes its ecient implementation in SV M light . The algorithm is based
on a decomposition strategy and addresses the problem of selecting the variables
for the working set in an eective and ecient way. Furthermore, a technique for
\shrinking" the problem during the optimization process is introduced. This is
found particularly eective for large learning tasks where the fraction of SVs is
small compared to the sample size, or when many SVs are at the upper bound. The
chapter also describes how this algorithm is eciently implemented in SV M light .
It has a memory requirement linear in the number of training examples and in the
number of SVs. Nevertheless, the algorithms can benet from additional storage
space, since the caching strategy allows an elegant trade-o between training time
and memory consumption.

11.9 Acknowledgements
This work was supported by the DFG Collaborative Research Center on Complexity
Reduction in Multivariate Data (SFB475). Thanks to Alex Smola for letting me
use his solver. Thanks also to Shumeet Baluja and to John Platt for the data sets.

Generic author design sample pages 1998/07/09 14:59

 References

B. E. Boser, I. M. Guyon, and V. N. Vapnik. A training algorithm for optimal

margin classiers. In D. Haussler, editor, Proceedings of the 5th Annual ACM
Workshop on Computational Learning Theory, pages 144{152, Pittsburgh, PA,
July 1992. ACM Press.
P. E. Gill, W. Murray, and M. H. Wright. Practical Optimization. Academic Press,
1981.
T. Joachims. Text categorization with support vector machines. In European
Conference on Machine Learning (ECML), 1998.
E. Osuna, R. Freund, and F. Girosi. Support vector machines: Training and
applications. A.I. Memo (in press), MIT A. I. Lab., 1996.
E. Osuna, R. Freund, and F. Girosi. An improved training algorithm for support
vector machines. In J. Principe, L. Gile, N. Morgan, and E. Wilson, editors,
Neural Networks for Signal Processing VII | Proceedings of the 1997 IEEE
Workshop, pages 276 { 285, New York, 1997a. IEEE.
E. Osuna, R. Freund, and F. Girosi. Training support vector machines: An
application to face detection. In , editor, Proceedings CVPR'97, , 1997b. .
J. Platt. Sequential minimal optimization: A fast algorithm for training support
vector machines. Technical Report MSR-TR-98-14, Microsoft Research, 1998.
R. Vanderbei. Loqo: An interior point code for quadratic programming. Technical
Report SOR 94-15, Princeton University, 1994.
V. Vapnik. The Nature of Statistical Learning Theory. Springer Verlag, New York,
1995.
J. Werner. Optimization - Theory and Applications. Vieweg, 1984.
G. Zoutendijk. Methods of Feasible Directions: a Study in Linear and Non-linear
Programming. Elsevier, 1970.

11.10 Additional Remarks

2
The Pentium II takes only 65% of the time for running SV M light . Many thanks
to John Platt for the comparison.

Generic author design sample pages 1998/07/09 14:59

 56 REFERENCES

11.11 Notation
We conclude with a list of symbols which are used throughout the book, unless
stated otherwise.
R the set of reals
N the set of natural numbers
k Mercer kernel
F feature space
N dimensionality of input space
xi input patterns
yi target values, or (in pattern recognition) classes
` number of training examples
w weight vector
b constant oset (or threshold)
h VC-dimension
" parameter of the "-insensitive loss function
i Lagrange multiplier
 vector of all Lagrange multipliers
i slack variables
Q Hessian of the quadratic program
(x
y) dot product between patterns x and yp
k:k 2-norm (Euclidean distance), kxk := (x
x)
ln logarithm to base e
log2 logarithm to base 2

11.12 Equations from the Introduction

RBF-Kernel:
,

k(x; y) = exp ,kx , yk2=(2 2 ) ; (11.38)

Primal optimization problem:

minimize  (w) = 12 kwk2 (11.39)

subject to yi
((w
xi) + b)  1; i = 1; : : :; `: (11.40)

Decision function:
X̀ !
f (x) = sgn yi i
(x
xi ) + b (11.41)
i=1

Generic author design sample pages 1998/07/09 14:59