Linearized Additive Classifiers

1 Introduction

Non parametric models for classification have become attractive since the introduction of kernel methods like the Support Vector Machines (SVMs) [1]

. The complexity of the learned models scale with the data, which gives them desirable asymptotic properties. However from an estimation point of view, parametric models can offer significant statistical and computational advantages. Recent years has seen a shift of focus from non-parametric models to semi-parametric for learning classifiers. This includes the work of Rahimi and Recht

[15], where they compute an approximate feature map

ϕ

, for shift invariant kernels

K (| x - y |) \sim ϕ (x)^{'} ϕ (y)

, and solve the kernel problem approximately using a linear problem. This line of work has become extremely attractive, with the advent of several algorithms for training linear classifiers efficiently (for e.g. LIBLINEAR [6], PEGASOS [16]), including online variants which have very low memory overhead.

Additive models, i.e., functions that decompose over dimensions $(f (x) = \sum_{i} f_{i} (x_{i}))$ , are a natural extension to linear models, and arise naturally in many settings. In particular if the kernel is additive, i.e. $K (x, y) = \sum_{i} K_{i} (x_{i}, y_{i})$

then the learned SVM classifier is also additive. A large number of useful kernels used in computer vision are based on comparing distributions of low level features on images and are additive, for e.g., histogram intersection and

χ^{2}

kernel [11]. This one dimensional decomposition allows one to compute approximate feature maps independently for each dimension, leading to very compact feature maps, making estimation efficient. This line of work has been explored by Maji and Berg [11] where they construct approximate feature maps for the

min

kernel, and learn piecewise linear functions in each dimension. For

γ

-homogenous additive kernels, Vedaldi and Zisserman [17] propose to use the closed form features of Hein and Bousquet [8] to construct approximate feature maps.

Smoothing splines [18] are another way of estimating additive models, and are well known in the statistical community. Ever since Generalized Additive Models (GAMs) were introduced by Hastie and Tibshirani [7], many practical approaches to training such models for regression have emerged, for example the P-Spline formulation of Eilers and Marx [4]. However these algorithms do not scale to extremely large datasets and high-dimensional features typical of image or text classification datasets.

In this work we show that the spline framework can used to derive embeddings to train additive classifiers efficiently as well. We propose two families of embeddings which have the property that the underlying additive classifier can be learned directly by estimating a linear classifier in the embedded space. The first family of embeddings are based on the Penalized Spline (“P-Spline”) formulation of additive models (Eilers and Marx [4]) where the function in each dimension is represented using a uniformly spaced spline basis and the regularization penalizes the difference between adjacent spline coefficients. The second class of embeddings are based on a generalized Fourier expansion of the function in each dimension.

This work ties the literature of additive model regression and linear SVMs to develop algorithms to train additive models in the classification setting. We discuss how our additive embeddings are related to additive kernels in Section 4. In particular our representations include those of [11] as a special case arising from a particular choice of B-Spline basis and regularization. An advantage of our representations is that it allows explicit control of the smoothness of the functions and the choice of basis functions, which may be desirable in certain situations. Moreover the sparsity of some of our representations lead to efficient training algorithms for smooth fits of functions. We summarize the previous work in the next section.

2 Previous Work

The history of learning additive models goes back to [7], who proposed the “backfitting algorithm” to estimate additive models. Since then many practical approaches have emerged, the most prominent of which is the Penalized Spline formulation (“P-Spline”) proposed by [4], which consists of modeling the one dimensional functions using a large number of uniformly spaced B-Spline basis. Smoothness is ensured by penalizing the differences between adjacent spline coefficients. We describe the formulation in detail in Section 3. A key advantage of this formulation was the whole problem could be solved using a linear system.

Given data $(x^{k}, y^{k}), k = 1, \dots, m$ with $x^{k} \in R^{D}$ and $y^{k} \in {- 1, + 1}$ , discriminative training of functions often involve an optimization such as:

min f \in F \sum k l (y^{k}, f (x^{k})) + λ R (f)

(1)

where, $l$

is a loss function and

R (f)

is a regularization term. In the classification setting a commonly used loss function

l

is the hinge loss function:

l (y^{k}, f (x^{k})) = max (0, 1 - y^{k} f (x^{k}))

(2)

For various kernel SVMs the regularization penalizes the norm of the function in the implicit Reproducing Kernel Hilbert Space (RKHS), of the kernel. Approximating the RKHS of these additive kernels provides way of training additive kernel SVM classifiers efficiently. For shift invariant kernels, Rahimi and Recht [15] derive features based on Boshner’s theorem. Vedaldi and Zisserman [17] propose to use the closed form features of Hein and Bousquet [8] to train additive kernel SVMs efficiently for many commonly used additive kernels which are $γ$ -homogenous. For the $min$ kernel, Maji and Berg [11] propose an approximation and an efficient learning algorithm, and our work is closely related to this.

In the additive modeling setting, a typical regularization is to penalize the norm the $d$ th order derivatives of the function in each dimension, $i . e .$ , $R (f) = \sum_{i} \int_{- \infty}^{\infty} f_{i}^{d} (t)^{2}$ . Our features are based on encodings that enable efficient evaluation and computation of this regularization. For further discussion we assume that the features $x^{k}$ are one dimensional. Once the embeddings are derived for the one dimensional case, we note that the overall embedding is concatenation of the embeddings in each dimension as the classifiers are additive.

3 Spline Embeddings

Eilers and Marx [4] proposed a practical modeling approach for GAMs. The idea is based on the representing the functions in each dimension using a relatively large number of uniformly spaced B-Spline basis. The smoothness of these functions is ensured by penalizing the first or second order differences between the adjacent spline coefficients. Let $ϕ (x^{k})$ denote the vector with entries $ϕ_{i} (x^{k})$ , the projection of $x^{k}$ on to the $i$ th basis function. The P-Spline optimization problem for the classification setting with the hinge loss function consists of minimizing $c (w)$ :

c (w) = \frac{λ}{2} w^{'} D_{d}^{'} D_{d} w + \frac{1}{n} \sum k max (0, 1 - y^{k} (w^{'} ϕ (x^{k})))

(3)

The matrix $D_{d}$ constructs the $d$ th order differences of $α$ :

D_{d} α = Δ^{d} α

(4)

The first difference of $α$ , $Δ^{1} α$ is a vector of elements $α_{i} - α_{i + 1}$ . Higher order difference matrices can be computed by repeating the differencing. For a $n$ dimensional basis, the difference matrix $D_{1}$ is a $(n - 1) \times n$ matrix with $d_{i, i} = 1$ , $d_{i, i + 1} = - 1$ and zero everywhere else. The matrices $D_{1}$ and $D_{2}$ are as follows:

D_{1} = ⎛ ⎜ ⎜ ⎜ ⎝ \begin{matrix} 1 & - 1 1 & - 1 \dots 1 & - 1 \end{matrix} ⎞ ⎟ ⎟ ⎟ ⎠; D_{2} = ⎛ ⎜ ⎜ ⎜ ⎝ \begin{matrix} 1 & - 2 & 1 1 & - 2 & 1 \dots 1 & - 2 & 1 \end{matrix} ⎞ ⎟ ⎟ ⎟ ⎠

To enable a reduction to the linear case we propose a slightly different difference matrix $D_{1}$ . We let $D_{1}$ be a $n \times n$ matrix with $d_{i, i} = 1, d_{i, i - 1} = - 1$ . This is same as the first order difference matrix proposed by Eilers and Marx, with one more row added on top. The resulting difference matrices $D_{1}$ and $D_{2} = D_{1}^{2}$ are both $n \times n$ matrices:

D_{1} = ⎛ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ \begin{matrix} 1 - 1 & 1 - 1 & 1 \dots - 1 & 1 - 1 & 1 \end{matrix} ⎞ ⎟ ⎟ ⎟ ⎟ ⎟ ⎟ ⎟ ⎟ ⎠; D_{2} = ⎛ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ \begin{matrix} 1 - 2 & 1 1 & - 2 & 1 1 & - 2 & 1 \dots 1 & - 2 & 1 \end{matrix} ⎞ ⎟ ⎟ ⎟ ⎟ ⎟ ⎟ ⎟ ⎟ ⎠

The first row in $D_{1}$

has the effect of penalizing the norm on the first coefficient of the spline basis, which plays the role of regularization in the linear setting (e.g. ridge regression, linear SVMs, etc). Alternatively one can think of this as an additional basis at left most point with its coefficient set to zero.

The key advantage is that the matrix $D_{1}$ is invertible and has a particularly simple form which allows us to linearize the whole system. We will also show in Section 4 that the derived embeddings also approximate the learning problem of kernel SVM classifier using the

min

kernel (

K_{min}

) for a particular choice of spline basis.

K_{min} (x, y) = \sum i min (x_{i}, y_{i})

(5)

Given the choice of the regularization matrix $D_{d}$ which is invertible, one can linearize the whole system by re-parametrizing $w$ by $D_{d}^{- 1} w$ , which results in :

c (w) = \frac{λ}{2} w^{'} w + \frac{1}{n} \sum k max (0, 1 - y^{k} (w^{'} D_{d}^{^{'} - 1} ϕ (x^{k})))

(6)

Therefore the whole classifier is linear on the features $ϕ^{d} (x^{k}) = D_{d}^{^{'} - 1} ϕ (x^{k})$ , i.e. the optimization problem is equivalent to

c (w) = \frac{λ}{2} w^{'} w + \frac{1}{n} \sum k max (0, 1 - y^{k} (w^{'} ϕ^{d} (x^{k})))

(7)

The inverse matrices $D_{1}^{^{'} - 1}$ and $D_{2}^{^{'} - 1}$ are both upper triangular matrices. The matrix $D_{1}^{^{'} - 1}$ has entries $d_{i, j} = 1, j \geq i$ and $D_{2}^{^{'} - 1} = D_{1}^{^{'} - 2}$ has entries $d_{i, j} = j - i + 1, j \geq i$ and look like:

D_{1}^{^{'} - 1} = ⎛ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ \begin{matrix} 1 & 1 & 1 & \dots & 1 & 1 1 & 1 & \dots & 1 & 1 1 & \dots & 1 & 1 \dots & \dots & \dots 1 & 1 1 \end{matrix} ⎞ ⎟ ⎟ ⎟ ⎟ ⎟ ⎟ ⎟ ⎟ ⎠; D_{2}^{^{'} - 1} = ⎛ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ \begin{matrix} 1 & 2 & 3 & \dots & n - 1 & n 1 & 2 & \dots & n - 2 & n - 1 1 & \dots & n - 3 & n - 2 \dots & \dots & \dots 1 & 2 1 \end{matrix} ⎞ ⎟ ⎟ ⎟ ⎟ ⎟ ⎟ ⎟ ⎟ ⎠

We refer the readers to [5] for an excellent review of additive modeling using splines. Figure 1 shows the $ϕ^{d}$ for various choices of the regularization degree $d = 0, 1, 2$ and B Splines basis, linear, quadratic and cubic.

Figure 1: Local basis functions for linear (left), quadratic (middle) and cubic (right) for various regularizations degrees $d$ . In each figure $ϕ^{d}$ refers to the dense features $D_{d}^{^{'} - 1} ϕ$ . When $d = 0$ , the function shown in the local basis of B-Splines. When $d = r + 1$ , where $r$ is degree of the B-Spline basis, then $ϕ^{d}$ are truncated polynomials basis, $(x - τ_{i})_{+}^{r}$ (see Section 4).

3.1 Generalized Fourier Embeddings

Generalized Fourier expansion provides an alternate way of fitting additive models. Let $ψ_{1} (x), ψ_{2} (x), \dots, ψ_{n} (x)$ be a orthogonal basis system in the interval $[a, b]$ , wrto. a weight function $w (x)$ , i.e. we have $\int_{a}^{b} ψ_{i} (x) ψ_{j} (x) w (x) d x = 0, i \neq j$ . Given a function $f (x) = \sum_{i} a_{i} ψ_{i} (x)$ , the regularization can be written as:

\int_{a}^{b} f^{d} (x)^{2} w (x) d x = \int_{a}^{b} {(\sum i a_{i} ψ_{i}^{d} (x))}_{i}^{2} w (x) d x = \int_{a}^{b} (\sum i, j a_{i} a_{j} ψ_{i}^{d} (x) ψ_{j}^{d} (x)) w (x) d x

(8)

Consider an orthogonal family of basis functions which are differentiable and whose derivatives are also orthogonal. One can normalize the basis such that $\int_{a}^{b} ψ_{i}^{d} (x) ψ_{j}^{d} (x) w (x) d x = δ_{i j}$ . In this case the regularization has a simple form:

\int_{a}^{b} f^{d} (x)^{2} w (x) d x = \int_{a}^{b} (\sum i, j a_{i} a_{j} ψ_{i}^{d} (x) ψ_{j}^{d} (x)) w (x) d x = \sum i a_{i}^{2}

(9)

Thus the overall regularized additive classifier can be learned by learning a linear classifier in the embedded space $ψ (x)$ . In practice one can approximate the scheme by using a small number of basis function. We propose two practical ones with closed form embeddings:

Fourier basis.

The classic Fourier basis functions ${1, cos (π x), sin (π x), cos (2 π x), sin (2 π x), \dots}$ are orthogonal in $[- 1, 1]$ , wrto. the weight function $w (x) = 1$ . The derivatives are also in the same family (except the constant basis function), hence are also orthonormal. The normalized feature embeddings for $d = 1, 2$ are shown in Table 1.

Hermite basis.

Hermite polynomials also are an orthogonal basis system with orthogonal derivatives wrto. the weight function $e^{- x^{2} / 2}$ . Using the following identity:

\int_{- \infty}^{\infty} H_{m} (x) H_{n} (x) e^{- x^{2} / 2} d x = \sqrt{2 π} n! δ_{m n}

(10)

and the property that $H_{n}^{'} = n H_{n - 1}$ (Apell sequence), one can obtain closed form features for $d = 1, 2$ as shown in Table 1. It is also known that the family of polynomial basis functions which are orthogonal and whose derivatives are orthogonal belong to one of three families, Jacobi, Laguerre or Hermite [19]. The extended support of the weight function of the Hermite basis, makes them well suited for additive modeling.

Although both these basis are complete, for practical purposes one has to use the first few basis. The quality of approximation depends on how well the underlying function can be approximated by these chosen basis, for example, low degree polynomials are better represented by Hermite basis.

Fourier	Hermite
$x \in [- 1, 1]$ , $w (x) = 1$	$x \in N (0, 1)$ , $w (x) = e^{- x^{2} / 2}$
$ϕ_{n}^{1} (x) = {\frac{cos (n π x)}{n}, \frac{sin (n π x)}{n}}$	$ϕ_{n}^{1} (x) = \frac{H_{n} (x)}{\sqrt{n n!}}$
$ϕ_{n}^{2} (x) = {\frac{cos (n π x)}{n^{2}}, \frac{sin (n π x)}{n^{2}}}$	$ϕ_{1}^{2} (x) = ϕ_{1}^{1} (x)$ , $ϕ_{n}^{2} (x) = \frac{H_{n} (x)}{\sqrt{n (n - 1) n!}}$ , $n > 1$

Table 1: Fourier and Hermite encodings

ϕ^{d}

for spline regression penalizing the

d

th derivative.

4 Additive Kernel Reproducing Kernel Hilbert Space & Spline Embeddings

We begin by showing the close resemblance of the spline embeddings to the $min$ kernel. To see this, let the features in $[0, 1)$ be represented with $N + 1$ uniformly spaced linear spline basis centered at $0, \frac{1}{N}, \frac{2}{N}, \dots, 1$ . Let $r = ⌊ N x ⌋$ and let $α = N x - r$ . Then the features $ϕ (x)$ is given by $ϕ_{r} (x) = 1 - α, ϕ_{r + 1} (x) = α$ and the features $ϕ^{1} (x)$ for $D_{1}$ matrix is given by $ϕ_{i}^{1} (x) = 1$ , if $i \leq r$ and $ϕ_{r}^{1} (x) = α$ . It can be seen that these features closely approximates the $min$ kernel, i.e.

\frac{1}{N} ϕ^{1} (x)^{'} ϕ^{1} (y) \approx min (x, y) + 1

(11)

The features $ϕ^{1} (x) = D_{1}^{^{'} - 1} ϕ (x)$ constructs a unary like representation where the number of ones equals the position of the bin of $x$ . One can verify that for a B-spline basis of degree $r$ ( $r = 1, 2, 3$ ), the following holds:

\frac{1}{N} ϕ^{1} (x)^{'} ϕ^{1} (y) = min (x, y) + \frac{r + 1}{2}, if | x - y | \geq \frac{r}{N}

(12)

Define $K_{d}^{r}$ the kernel corresponding to a B-Spline basis of degree $r$ and regularization matrix $D_{d}$ as follows:

K_{d}^{r} (x, y) = \frac{1}{N} ϕ^{d} (x)^{'} ϕ^{d} (y) - \frac{r + 1}{2} = \frac{1}{N} ϕ (x)^{'} D_{d}^{- 1} D_{d}^{^{'} - 1} ϕ (y) - \frac{r + 1}{2}

(13)

Figure 2 shows $K_{r}^{1}$ for $r = 1, 2, 3$ corresponding to a linear, quadratic and cubic B-Spline basis. In a recent paper, Maji and Berg [11], propose to use linear spline basis and a $D_{1}$ regularization, to train approximate intersection kernel SVMs, which in turn approximate arbitrary additive classifiers. Our features can be seen as a generalization to this work which allows arbitrary spline basis and regularizations.

B-Splines are closely related to the truncated polynomial kernel [18, 14] which consists of uniformly spaced knots $τ_{1}, \dots, τ_{n}$ and truncated polynomial features:

ϕ_{i} (x) = (x - τ_{i})_{+}^{p}

(14)

However these features are not as numerically stable as B-Spline basis (see [5] for an experimental comparison). Truncated polynomials of degree $k$ corresponds to a B-Spline basis of degree $k$ and $D_{k + 1}$ regularization, i.e, same as $K_{k}^{k + 1}$ kernel, when the knots are uniformly spaced. This is because B-Splines are derived from truncated polynomial basis by repeated application of the difference matrix $D_{1}$ [3]. As noted by the authors in [5], one of the advantages of the P-Spline formulation is that is decouples the order of regularization and B Spline basis. Typically $D_{1}$ regularization provides sufficient smoothness in our experiments.

Figure 2: Spline Kernels. $K_{min} (x, y), x, y \in [0, 1]$ along with $K_{r}^{1}$ for $r = 1, 2, 3$ corresponding to linear, quadratic and cubic B-Spline basis. Using uniformly spaced basis separated by $0.1$ , these kernels closely approximate the $min$ kernel as seen in the difference image. The approximation is exact when $| x - y | > 0.1 r$ .

5 Optimizations for Efficient Learning for B-Spline embeddings

For B-spline basis one can exploit the sparsity to speed-up linear solvers. The classification function is based on evaluating $w^{'} D_{d}^{^{'} - 1} ϕ (x)$ . Most methods for training linear methods are based on evaluating the classifier and updating the classifier if the classification is incorrect. Since the number of such evaluations are larger than the number of updates, it is is much more efficient to maintain $w_{d} = D_{d}^{- 1} w$ and use sparse vector multiplication. Updates to the weight vector $w$ and $w_{d}$ for various gradient descent algorithms look like:

w^{t} \leftarrow w^{t - 1} - η D_{d}^{^{'} - 1} ϕ (x^{k}), w_{d}^{t} = w_{d}^{t - 1} - η L_{d} ϕ (x^{k})

(15)

Where $η$ is a step and $L_{d} = D_{d}^{- 1} D_{d}^{^{'} - 1}$ . Unlike the matrix $D_{d}^{'} D_{d}$ , the matrix $L_{d}$ is a dense, and hence the updates to $w_{d}$ may change all the entries of $w_{d}$ . However, one can compute $L_{d} ϕ (x)$ in $2 d n$ steps instead of $n^{2}$ steps, exploiting the simple form of $D_{1}^{^{'} - 1}$ . Initialize $a_{i} = ϕ_{i} (x)$ then repeat step A, $d$ times followed by step B, $d$ times to compute $L_{d} ϕ (x)$ .

	step A	$:$	$a_{i} = a_{i} + a_{i + 1}, i = n - 1 to 1$
	step B	$:$	$a_{i} = a_{i} + a_{i - 1}, i = 2 to n$

6 Experiments

Often on large datasets consisting of very high dimensional features, to avoid the memory bottleneck, one may compute the encodings in the inner loop of the training algorithm. We refer this to as the “online” method. Our solver is based on LIBLINEAR, but can be easily used with any other solver. The custom solver allows us to exploit the sparsity of embeddings (Section 5). A practical regularization is $D_{0} = I$ with the B-Spline embeddings, where $I$

is the identity matrix, which leads to sparse features. This makes it difficult to estimate the weights on the basis functions which have no data, but one can use a higher order B-Spline basis, to somewhat mitigate this problem.

We present image classification experiments on two image datasets, MNIST [10] and Daimler Chrysler (DC) pedestrians [13]. On these datasets SVM classifiers based on histogram intersection kernel outperforms a linear SVM classifier [11, 12], when used with features based on a spatial pyramid of histogram of oriented gradients [2, 9]. We obtain the features from the author’s website for our experiments. The MNIST dataset has $60, 000$ instances and the features are $2172$ dimensional and dense, leading to $130, 320, 000$ non-zero entries. The DC dataset has three training sets and two test sets. Each training set has $19, 800$ instances and the features are $656$ dimensional and dense, leading to $12, 988, 800$ entries. These sizes are typical of image datasets and training kernel SVM classifiers often take several hours on a single machine.

Toy Dataset.

The points are sampled uniformly on a 2D grid $[- 1, 1] \times [- 1, 1]$ with the points satisfying $x^{2} + y^{2} \leq 1$ in the positive class and others as negative. Figure 3(b), shows the fits on the data along $x$ (or $y$ ) dimension using $4$ uniformly spaced B-spline basis of various degrees and regularizations. The quadratic and cubic splines offer smoother fits of the data. Figure 3(c,d) shows the learned functions using Fourier and Hermite embeddings of various degrees respectively.

Figure 3: (a) 2D data generated according to $x^{2} + y^{2} \leq 1$ . (b) B-Spline fits along $x$ for various degrees and regularizations and $4$ uniformly spaced bins in $[- 1, 1]$ . (c) Fourier fits along $x$ using $sin, cos$ features for various frequencies and regularizations. (d) Hermite fits along $x$ for various degrees and regularizations.

Effect of B-Spline parameter choices.

Table 2, shows the accuracy and training times as a function of the number of bins, regularization degree ( $D_{r}, r = 0, 1, 2$ ) and the B-Spline basis degree ( $d = 1, 2, 3)$ on the first split of the DC pedestrian dataset. We set $C = 1$ and the bias term $B = 1$ for training all the models. On this dataset we find that $r = 0, 1$ is more accurate than $r = 3$ and is significantly faster. In further experiments we only include the results of $r = 0, 1$ and $d = 1, 3$ . In addition, setting the regularization to zero ( $r = 0$ ), leads to very sparse features and can be used directly with any linear solver which can exploit this sparsity. The training time for B-Splines scales sub-linearly with the number of bins, hence better fits of the functions can be obtained without much loss in efficiency.

	Regularization
Degree	$D_{0}$	$D_{1}$	$D_{2}$
	$5$ bins
1	$06.60 s$ $(89.55 %)$	$20.27 s$ $(89.68 %)$	$041.60 s$ $(89.93 %)$
2	$08.74 s$ $(90.45 %)$	$30.47 s$ $(90.20 %)$	$080.25 s$ $(89.94 %)$
3	$11.68 s$ $(90.03 %)$	$49.85 s$ $(89.93 %)$	$143.50 s$ $(88.57 %)$
	$10$ bins
1	$05.61 s$ $(90.42 %)$	$23.06 s$ $(90.86 %)$	$077.99 s$ $(89.43 %)$
2	$08.10 s$ $(90.69 %)$	$29.97 s$ $(90.73 %)$	$126.03 s$ $(89.23 %)$
3	$11.59 s$ $(90.48 %)$	$42.26 s$ $(90.67 %)$	$193.47 s$ $(89.14 %)$
	$20$ bins
1	$05.96 s$ $(90.23 %)$	$32.43 s$ $(91.20 %)$	$246.87 s$ $(89.06 %)$
2	$07.26 s$ $(90.34 %)$	$34.99 s$ $(91.10 %)$	$328.32 s$ $(88.89 %)$
3	$10.08 s$ $(90.39 %)$	$42.88 s$ $(91.00 %)$	$429.57 s$ $(88.92 %)$

Table 2: B-Spline parameter choices on DC dataset. Training times and accuracies for various B-Spline parameters on the first split of DC dataset. In comparison training a linear model using LIBLINEAR takes

3.8 s

and achieves

81.5 %

accuracy. With

D_{0}

regularization, higher degree splines are more accurate, but with

D_{1}

regularization linear spline basis are as accurate as quadratic/cubic when the number of bins are large. Training using

D_{0}

regularization is about than

4 \times

faster than

D_{1}

. Higher order regularization seems unnecessary. Note that this implementation computes the encodings on the fly hence has the same memory overhead as LIBLINEAR.

Effect Fourier embedding parameter choices.

Table 3, shows the accuracy and training times for various Fourier embeddings on DC dataset. Before computing the generalized Fourier features, we first normalize the data in each dimension to $[- 1, 1]$ using:

x \leftarrow \frac{x - μ}{δ}, where, μ = \frac{x_{max} + x_{min}}{2}, δ = \frac{x_{max} - x_{min}}{2}

(16)

We precompute the features and use LIBLINEAR to train various models, since it is relatively more expensive to compute the features online. In this case the training times are similar to that of B-Spline models. However, precomputing and storing the features may not be possible on very large scale datasets.

	Fourier				Hermite
	$r = 1$		$r = 2$		$r = 1$		$r = 2$
Degree	Accuracy	Time	Accuracy	Time	Accuracy	Time	Accuracy	Time
1	$88.94 %$	$07.0 s$	$88.94 %$	$07.0 s$	$84.17 %$	$02.8 s$	$84.17 %$	$02.8 s$
2	$89.59 %$	$10.2 s$	$89.64 %$	$10.2 s$	$88.01 %$	$04.6 s$	$88.01 %$	$04.6 s$
3	$88.99 %$	$12.7 s$	$89.77 %$	$12.8 s$	$88.22 %$	$07.7 s$	$88.70 %$	$09.9 s$
4	$89.77 %$	$16.0 s$	$89.84 %$	$15.9 s$	$89.00 %$	$12.6 s$	$89.05 %$	$11.9 s$

Table 3: Fourier embeddings on DC dataset. Accuracies and training times (encoding + training) for various Fourier embeddings on the first split of the DC pedestrian dataset. Note that the methods are trained by first encoding the features and training a linear model using LIBLINEAR.

Comparison of various additive models.

Table 4, shows the accuracy and training times of various additive models compared to linear and the more expensive $min$ kernel SVM on all the $6$ training and test set combinations of DC dataset. The optimal parameters were found on the first training and test set. The additive models are up to $50 \times$ faster to train and are as accurate as the $min$ kernel SVM. The B-Spline additive models significantly outperform a linear SVM on this dataset at the expense of small additional training time.

Table 5 shows the accuracies and training times of various additive models on the MNIST dataset. We train one-vs-all classifiers for each digit and the classification scores are normalized by passing them through a logistic. During testing, each example given the label of the classifier with the highest response. The optimal parameters for training were found using 2-fold cross validation on the training set. Once again the additive models significantly outperform the linear classifier and closely matches the accuracy of $min$ kernel SVM, while being $50 \times$ faster.

Method	Test Accuracy	Training Time
SVM (linear) + LIBLINEAR	$81.49$ ( $1.29$ )	$3.8$ s
SVM ( $min$ ) + LIBSVM	$89.05$ ( $1.42$ )	$363.1$ s
		online	batch
B-Spline $(r = 0, d = 1, n = 05)$	$88.51$ ( $1.35$ )	$5.9$ s	-
B-Spline $(r = 0, d = 3, n = 05)$	$89.00$ ( $1.44$ )	$10.8$ s	-
B-Spline $(r = 1, d = 1, n = 10)$	$89.56$ ( $1.35$ )	$17.2$ s	-
B-Spline $(r = 1, d = 3, n = 10)$	$89.25$ ( $1.39$ )	$19.2$ s	-
Fourier $(r = 1, d = 2)$	$88.44$ ( $1.43$ )	$159.9$ s	$12.7$ s ( $4 \times$ memory)
Hermite $(r = 1, d = 4)$	$87.67$ ( $1.26$ )	$35.5$ s	$12.6$ s ( $4 \times$ memory)

Table 4: Training times and test accuracies of various additive classifiers on DC dataset. The online training method compute the encodings on the fly and the batch method computes the encoding once and uses LIBLINEAR to train a linear classifier. For B-Splines the online method is faster hence we omit the training times for the batch method. All the additive classifiers outperform the linear SVM, while being up to

50 \times

faster than

min

SVM.

Method	Test Error	Training Time
SVM (linear) + LIBLINEAR	$1.44 %$	$6.2$ s
SVM ( $min$ ) + LIBSVM	$0.79 %$	$\sim 2.5$ hours
B-Spline $(r = 0, d = 1, n = 20)$	$0.88 %$	$31.6$ s
B-Spline $(r = 0, d = 3, n = 20)$	$0.86 %$	$51.6$ s
B-Spline $(r = 1, d = 1, n = 40)$	$0.81 %$	$157.7$ s
B-Spline $(r = 1, d = 3, n = 40)$	$0.82 %$	$244.9$ s
Hermite $(r = 1, d = 4)$	$1.06 %$	$358.6$ s

Table 5: Test error and mean training times per digit for various additive classifiers on MNIST. For B-Splines the online method is faster hence we omit the training times for the batch method. All the additive classifiers outperform the linear SVM, while being up to

50 \times

faster than

min

SVM.

7 Conclusion

We have proposed a family of embeddings which enable efficient learning of additive classifiers. We advocate the use B-Splines based embeddings because they are are efficient to compute and are sparse, which enables us to train these models with a small memory overhead by computing the embeddings on the fly even when the number of basis are large and can be seen as a generalization of [11]. Generalized Fourier features are low dimensional, but are expensive to compute and so are more suitable if the projected features can be precomputed and stored. The proposed classifiers outperform linear classifiers and match the significantly more expensive kernel SVM classifiers at a fraction of the training time. On both the MNIST and DC datasets, linear B-Spline and $D_{1}$ regularization works the best and closely approximates the learning problem of $min$ kernel SVM. Higher degree splines are useful when used with $D_{0}$ regularization, have even faster training times but worse accuracies than $D_{1}$ regularization. The code for training various spline models proposed in the paper has been packaged as a library, LIBSPLINE, which will be released upon the publication of this paper.

References

[1] B. Boser, I. Guyon, and V. Vapnik. A training algorithm for optimal margin classifiers. In
Proceedings of the fifth annual workshop on Computational learning theory
, pages 144–152. ACM, 1992.
[2] N. Dalal and B. Triggs. Histograms of oriented gradients for human detection. In CVPR, volume 1, pages 886–893. IEEE, 2005.
[3] C. De Boor. A practical guide to splines. Springer Verlag, 2001.
[4] P. Eilers and B. Marx. Generalized linear additive smooth structures. Journal of Computational and Graphical Statistics, 11(4):758–783, 2002.
[5] P. Eilers and B. Marx. Splines, knots, and penalties. Wiley Interdisciplinary Reviews: Computational Statistics, 2005.
[6] R. Fan, K. Chang, C. Hsieh, X. Wang, and C. Lin. Liblinear: A library for large linear classification.
The Journal of Machine Learning Research
, 9:1871–1874, 2008.
[7] T. Hastie and R. Tibshirani. Generalized additive models. Chapman & Hall/CRC, 1990.
[8] M. Hein and O. Bousquet.
Hilbertian metrics and positive definite kernels on probability measures.
In Proceedings of AISTATS, volume 2005. Citeseer, 2005.
[9] S. Lazebnik, C. Schmid, and J. Ponce. Beyond bags of features: Spatial pyramid matching for recognizing natural scene categories. In
Computer Vision and Pattern Recognition, 2006 IEEE Computer Society Conference on
, volume 2, pages 2169–2178. Ieee, 2006.
[10] Y. LeCun and C. Cortes.
The mnist database of handwritten digits, 1998.
[11] S. Maji and A. Berg. Max-margin additive classifiers for detection. In ICCV, pages 40–47. IEEE, 2009.
[12] S. Maji and J. Malik. Fast and accurate digit classification. Technical Report UCB/EECS-2009-159, EECS Department, University of California, Berkeley, Nov 2009.
[13] S. Munder and D. Gavrila. An experimental study on pedestrian classification. IEEE transactions on pattern analysis and machine intelligence, pages 1863–1868, 2006.
[14] N. Pearce and M. Wand. Penalized splines and reproducing kernel methods. The american statistician, 60(3):233–240, 2006.
[15] A. Rahimi and B. Recht. Random features for large-scale kernel machines. NIPS, 20:1177–1184, 2008.
[16] S. Shalev-Shwartz, Y. Singer, and N. Srebro. Pegasos: Primal estimated sub-gradient solver for svm. In ICML, pages 807–814. ACM, 2007.
[17] A. Vedaldi and A. Zisserman. Efficient additive kernels via explicit feature maps. In CVPR, pages 3539–3546. IEEE, 2010.
[18] G. Wahba. Spline models for observational data, volume 59. Society for Industrial Mathematics, 1990.
[19] M. Webster. Orthogonal polynomials with orthogonal derivatives. Mathematische Zeitschrift, 39:634–638, 1935.


$K_{min}$	$K_{1}^{1}$	$K_{min} - K_{1}^{1}$	$K_{2}^{1}$	$K_{min} - K_{2}^{1}$	$K_{3}^{1}$	$K_{min} - K_{3}^{1}$

Linearized Additive Classifiers

Authors

Accelerating Kernel Classifiers Through Borders Mapping

Statistical Inference for Generalized Additive Partially Linear Model

When is an automatic set an additive basis?

Rank and Kernel of F_p-Additive Generalised Hadamard Codes

Post-Regularization Confidence Bands for High Dimensional Nonparametric Models with Local Sparsity

KASAM: Spline Additive Models for Function Approximation

Generalized Intersection Kernel

1 Introduction

2 Previous Work