## Abstract

We consider the problem of classifying data manifolds where each manifold represents invariances that are parameterized by continuous degrees of freedom. Conventional data augmentation methods rely on sampling large numbers of training examples from these manifolds. Instead, we propose an iterative algorithm, $MCP$, based on a cutting plane approach that efficiently solves a quadratic semi-infinite programming problem to find the maximum margin solution. We provide a proof of convergence as well as a polynomial bound on the number of iterations required for a desired tolerance in the objective function. The efficiency and performance of $MCP$ are demonstrated in high-dimensional simulations and on image manifolds generated from the ImageNet data set. Our results indicate that $MCP$ is able to rapidly learn good classifiers and shows superior generalization performance compared with conventional maximum margin methods using data augmentation methods.

## 1 Introduction

Handling object variability is a major challenge for machine learning systems. For example, in visual recognition tasks, changes in pose, lighting, identity, or background can result in large variability in the appearance of objects (Hinton, Dayan, & Revow, 1997). Techniques to deal with this variability have been the focus of much recent work, especially with convolutional neural networks consisting of many layers. The manifold hypothesis states that natural data variability can be modeled as lower-dimensional manifolds embedded in higher-dimensional feature representations (Bengio, Courville, & Vincent, 2013). A deep neural network can then be understood as disentangling or flattening the data manifolds so that they can be more easily read out in the final layer (Brahma, Wu, & She, 2016). Manifold representations of stimuli have also been utilized in neuroscience, where different brain areas are believed to untangle and reformat their representations (Riesenhuber & Poggio, 1999; Serre, Wolf, & Poggio, 2005; Hung, Kreiman, Poggio, & DiCarlo, 2005; DiCarlo & Cox, 2007; Pagan, Urban, Wohl, & Rust, 2013).

This article addresses the problem of classifying data manifolds that contain invariances with a number of continuous degrees of freedom. These invariances may be modeled using prior knowledge, manifold learning algorithms (Tenenbaum, 1998; Roweis & Saul, 2000; Tenenbaum, De Silva, & Langford, 2000; Belkin & Niyogi, 2003; Belkin, Niyogi, & Sindhwani, 2006; Canas, Poggio, & Rosasco, 2012), or generative neural networks via adversarial training (Goodfellow et al., 2014). Based on knowledge of these structures, other work has considered building group-theoretic invariant representations (Anselmi et al., 2013) or constructing invariant metrics (Simard, Le Cun, & Denker, 1994). Most approaches today rely on data augmentation by explicitly generating virtual examples from these manifolds (Niyogi, Girosi, & Poggio, 1998; Schölkopf, Burges, & Vapnik, 1996). Unfortunately, the number of samples needed to successfully learn the underlying manifolds may increase the original training set by more than a thousand-fold (Krizhevsky, Sutskever, & Hinton, 2012).

We propose a new method, the manifold cutting plane algorithm ($MCP$), which uses knowledge of the manifolds to efficiently learn a maximum margin classifier. Figure 1 illustrates the problem in its simplest form, binary classification of manifolds with a linear hyperplane, with extensions to this basic model discussed later. Given a number of manifolds embedded in a feature space, the $MCP$ algorithm learns a weight vector $w\u2192$ that separates positively labeled manifolds from negatively labeled manifolds with the maximum margin. Although the manifolds consist of uncountable sets of points, the $MCP$ algorithm is able to find a good solution in a provably finite number of iterations and training examples.

Support vector machines (SVM) can learn a maximum margin classifier given a finite set of training examples (Vapnik, 1998); however, with conventional data augmentation methods, the number of training examples increases exponentially, rendering the standard SVM algorithm intractable. Methods such as shrinkage and chunking to reduce the complexity of SVM have been studied in the context of dealing with large-scale data sets (Smola & Schölkopf, 1998), but the resultant kernel matrix may still be very large. Other methods that subsample the kernel matrix (Lee & Mangasarian, 2001) or reduce the number of training samples (Wang, Neskovic, & Cooper, 2005; Smola & Schölkopf, 1998) are infeasible when the input data come from manifolds with an uncountable set of examples.

Our $MCP$ algorithm directly handles the uncountable set of points in the manifolds by solving a quadratic semi-infinite programming problem (QSIP). $MCP$ is based on a cutting plane method that iteratively refines a finite set of training examples to solve the underlying QSIP (Fang, Lin, & Wu, 2001; Kortanek & No, 1993; Liu, Teo, & Wu, 2004). The cutting plane method was also previously shown to efficiently handle learning problems with a finite number of examples but an exponentially large number of constraints (Joachims, 2006) by adding constraints successively. We provide a novel analysis of the convergence of $MCP$ with both hard and soft margins. When the problem is realizable, the convergence bound explicitly depends on the margin value, whereas with a soft margin and slack variables, the bound depends linearly on the number of manifolds.

The article is organized as follows. We first consider the hard margin problem and analyze the simplest form of the $MCP$ algorithm. Next, we introduce slack variables in $MCP$, one for each manifold, and analyze its convergence with additional auxiliary variables. We then demonstrate the application of $MCP$ to both high-dimensional synthetic data manifolds and feature representations of images undergoing a variety of warpings. We compare its performance in both efficiency and generalization error with conventional SVMs using data augmentation techniques. Finally, we discuss some natural extensions and potential future work on $MCP$ and its applications.

## 2 Manifolds Cutting Plane Algorithm with Hard Margin

In this section, we first consider the problem of classifying a set of manifolds when they are linearly separable. This allows us to introduce the simplest version of the $MCP$ algorithm, along with the appropriate definitions and QSIP formulation. We analyze the convergence of the simple algorithm and prove an upper bound on the number of errors the algorithm can make in this setting.

### 2.1 Hard-Margin QSIP

This is the primal formulation of the problem, where maximizing the margin $\kappa =1||w\u2192||$ is equivalent to minimizing the squared norm $12||w\u2192||2.$ We denote the maximum margin attainable by $\kappa *$ and the optimal solution as $w\u2192*$. For simplicity, we do not explicitly include the bias term here. A nonzero bias can be modeled by adding a feature of a constant value as a component to all the $x\u2192$. Note that the dual formulation of this QSIP is more complicated, involving optimization of nonnegative measures over the manifolds. In order to solve the hard-margin QSIP, we propose the following simple $MCP$ algorithm.

### 2.2 $MCPsimple$ Algorithm

The $MCPsimple$ algorithm is an iterative algorithm to find the optimal $w\u2192$ in equation 2.1, based on a cutting-plane method for solving the QSIP. The general idea behind $MCPsimple$ is to start with a finite number of training examples, find the maximum margin solution for that training set, augment the training set by finding a point on the manifolds that violates the constraints, and iterating this process until a tolerance criterion is reached.

At each stage $k$ of the algorithm, there is a finite set of training points and associated labels. The training set at the $k$th iteration is denoted by the set $Tk=x\u2192i\u2208Mpi,ypi$ with $i=1,\u2026,Tk$ examples. For the $i$th pattern in $Tk$, $pi$ is the index of the manifold and $ypi$ its associated label.

In step 3 of the $MCPsimple$ algorithm, a point among the manifolds that violates the margin constraint needs to be found. The use of a separation oracle is common in other cutting plane algorithms such as those used for structural SVM's (Joachims, 2006) or linear mixed-integer programming (Marchand, Martin, Weismantel, & Wolsey, 2002). In our case, this requires determining the feasibility of $yp\u2329w\u2192(k),Mp(s\u2192)\u232a<1-\delta $ over the $D$-dimensional convex parameter set $s\u2192\u2208Sp$. When the manifold mapping is convex, feasibility in some cases can be determined analytically. More generally, it can be solved using modern convex techniques such as with projection-based methods (Bauschke & Borwein, 1996). For nonconvex mappings, we note that only the convex hulls of the manifolds, $convMp$, are relevant to the classification problem. Thus, in those situations, the separation oracle need only return a feasible point in the intersection of a manifold convex hull with the half-space determined by $w\u2192(k)$ and $\delta $. These intersection points can be computed using search techniques in the $D$-dimensional parameter set using gradient information, finite differences, or via convex relaxation techniques. We describe some specific methods of how separating points can be found in our experiments below.

### 2.3 Convergence of $MCPsimple$

The $MCPsimple$ algorithm will converge asymptotically to an optimal solution when it exists. Here we show that the $w\u2192(k)$ asymptotically converges to an optimal $w\u2192\u2605$. Denote the change in the weight vector in the $k$th iteration as $\Delta w\u2192(k)=w\u2192(k+1)-w\u2192(k)$. We present a set of lemmas and theorems leading up to the bounds on the number of iterations for convergence and the estimation of the objective function.

The change in the weights satisfies $\u2329\Delta w\u2192(k),w\u2192(k)\u232a\u22650$.

Define $w\u2192(\lambda )=w\u2192(k)+\lambda \Delta w\u2192(k)$. Then for all $0\u2264\lambda \u22641$, $w\u2192(\lambda )$ satisfies the constraints on the point set $Tk$: $ypi\u2329w\u2192(\lambda ),x\u2192i\u232a\u22651$ for all $x\u2192i,ypi\u2208Tk$. However, if $\u2329\Delta w\u2192(k),w\u2192(k)\u232a<0$, there exists a $0<\lambda '<1$ such that $\u2225w\u2192(\lambda ')\u22252<\u2225w\u2192(k)\u22252$, contradicting the fact that $w\u2192(k)$ is a solution to $SVMTk$.

Next, we show that the norm $\u2225w\u2192(k)\u22252$ must monotonically increase by a finite amount at each iteration.

In the $kth$ iteration of $MCPsimple$ algorithm, the increase in the norm of $w\u2192(k)$ is lower-bounded by $\u2225w\u2192(k+1)\u22252\u2265\u2225w\u2192(k)\u22252+\delta k2L2$, where $\delta k=1-ypk+1\u2329w\u2192(k),x\u2192k+1\u232a$ and $\u2225x\u2192k+1\u2225\u2264L$.

First, note that $\delta k>\delta \u22650$; otherwise, the algorithm stops. We have $\u2225w\u2192(k+1)\u22252=\u2225w\u2192(k)\u22252+\u2225\Delta w\u2192(k)\u22252+2\u2329w\u2192(k),\Delta w\u2192(k)\u232a\u2265\u2225w\u2192(k)\u22252+\u2225\Delta w\u2192(k)\u22252$ (see lemma 1). Consider the point added to set $Tk+1=Tk\u222ax\u2192k+1,ypk+1$. At this point, $ypk+1\u2329w\u2192(k+1),x\u2192k+1\u232a\u22651$, $ypk+1\u2329w(k),x\u2192k+1\u232a=1-\delta k$, hence $ypk+1\u2329\Delta w\u2192(k),x\u2192k+1\u232a\u2265\delta k$.

As a corollary, we see that this procedure is guaranteed to find a realizable solution if it exists in a finite number of steps.

The $MCPsimple$ algorithm converges to a zero error classifier in fewer than $L2\kappa \u26052$ iterations, where $\kappa \u2605$ is the optimal margin and $L$ bounds the norm of the points on the manifolds.

When there is an error, we have $\delta k>1$, and $\u2225w\u2192(k+1)\u22252\u2265\u2225w\u2192(k)\u22252+1L2$ (see equation 2.4). This implies the total number of possible errors is upper-bounded by $L2\kappa \u26052$.

With a finite tolerance $\delta >0$, we obtain a bound on the number of iterations required for convergence:

The $MCPsimple$ algorithm for a given tolerance $\delta >0$ terminates in fewer than $L2\kappa \u2605\delta 2$ iterations where $\kappa \u2605$ is the optimal margin and $L$ bounds the norm of the points on the manifolds.

Again, $\u2225w\u2192k\u22252\u2264\u2225w\u2192\u2605\u22252=1\kappa \u26052$, and each iteration increases the squared norm by at least $\delta 2L2$.

We can also bracket the error in the objective function after $MCPsimple$ terminates:

With tolerance $\delta >0$, after $MCPsimple$ terminates with solution $w\u2192MCP$, the optimal value $\u2225w\u2192\u2605\u2225$ of $SVMsimple$ is bracketed by $\u2225w\u2192MCP\u22252\u2264\u2225w\u2192\u2605\u22252\u226411-\delta 2\u2225w\u2192MCP\u22252$.

The lower bound on $\u2225w\u2192\u2605\u22252$ is as before. Since $MCPsimple$ has terminated, setting $w\u2192'=1(1-\delta )w\u2192MCP$ would make $w\u2192'$ feasible for $SVMsimple$, resulting in the upper bound on $\u2225w\u2192\u2605\u22252$.

## 3 $MCP$ with Slack Variables

In many classification problems, the manifolds may not be linearly separable due to their dimensionality, size, or correlation structure. In these situations, $MCPsimple$ will not be able to find a feasible solution, and there is no solution that has zero error over all the manifold points. To handle these problems, the classic approach is to introduce slack variables on each point ($SVMslack$) to control generalization error. For continuous manifolds, we define generalization performance as the classification error over distributions of points sampled from the manifolds $Mp$ with corresponding labeled outputs. The naive implementation of slack variables requires defining appropriate measures over entire manifolds and solving the optimization problem over infinite sets of slack variables. This is not computationally tractable, and we formulate a more efficient alternative version of QSIP with slack variables next.

### 3.1 QSIP with Manifold Slacks

In this work, we propose using only one slack variable per manifold for classification problems with nonseparable manifolds. This formulation demands that all the points on each manifold $x\u2192\u2208Mp$ obey an inequality constraint with one manifold slack variable, $yp\u2329w\u2192,x\u2192\u232a+\xi p\u22651$. As we will see, solving for this constraint is tractable, and the algorithm has good convergence guarantees.

### 3.2 $MCPslack$ Algorithm

### 3.3 Convergence of $MCPslack$

Here we show that the objective function $Fw\u2192,\xi \u2192=12\u2225w\u2192\u22252+C\u2211p=1P\xi p$ is guaranteed to increase by a finite amount with each iteration. This result is similar to Tsochantaridis, Joachims, Hofmann, and Altun (2005), but here we present proofs in the primal domain over an infinite number of examples.

We derive that the added point at each iteration must be a support vector for the next weight:

Suppose $ypk+1\u2329w\u2192(k+1),x\u2192k+1\u232a+\xi pk+1(k+1)=1+\epsilon $ for some $\epsilon >0$. Then we can choose $\lambda '=\delta k\delta k+\epsilon <1$ so that $w\u2192(\lambda ')=w\u2192(k)+\lambda '\Delta w\u2192(k)$ and $\xi \u2192(\lambda ')=\xi \u2192(k)+\lambda '\Delta \xi \u2192(k)$ satisfy the constraints for $SVMTk+1slack$. But from lemma 2, we have $Fw\u2192(\lambda '),\xi \u2192(\lambda ')<Fw\u2192(k+1),\xi \u2192(k+1)$, which contradicts the fact that $w\u2192(k+1)$ and $\xi \u2192(k+1)$ are a solution to $SVMTk+1$. Thus, $\epsilon =0$, and the point $x\u2192k+1,ypk+1$ must be a support vector for $SVMTk+1.$ Equation 3.5 results from subtracting equation 3.1 from 3.4.

We also derive a bound on the following quadratic function over nonnegative values:

The minimum value occurs when $x\u2605=\delta -K+$. When $K\u2265\delta $, then $x\u2605=0$, and the minimum is $12\delta 2$. When $K<\delta $, the minimum occurs at $K\delta -12K\u226512K\delta $. Thus, the lower bound is the smaller of these two values.

Using the lemmas above, the lower bound on the change in the objective function can be found:

The added point $x\u2192k$ comes from a particular manifold $Mpk$. If $\Delta \xi pk(k)\u22640$, from lemma 3, we have $ypk\u2329\Delta w\u2192(k),x\u2192k\u232a\u2265\delta k$. Then by the Cauchy-Schwarz inequality, $\u2225\Delta w\u2192(k)\u22252\u2265\delta k2L2$, which yields $Fw\u2192(k+1),\xi \u2192(k+1)-Fw\u2192(k),\xi \u2192(k)\u226512\delta k2L2$.

We consider the minimum value of the thresholds: $\eta =min\nu \epsilon \nu (k)$. We have two possibilities: $\eta $ is positive so that none of the points are support vectors for $SVMTkslack$, or $\eta =0$ so that at least one support vector lies in $Mpk$.

**Case $\eta >0$.**In this case, we define a linear set of slack variables:

**Case $\eta =0$.**In this case, we consider $\u025b=min\epsilon \nu (k)=0\epsilon \nu (k+1)\u22650$, that is, the minimal increase among the support vectors. We then define

Since the $MCPslack$ algorithm is guaranteed to increase the objective by a finite amount, it will terminate in a finite number of iterations if we require $\delta k>\delta $ for some positive $\delta >0$.

The $MCPslack$ algorithm for a given $\delta >0$ will terminate after at most $P\xb7max8CL2\delta 2,2\delta $ iterations, where $P$ is the number of manifolds and L bounds the norm of the points on the manifolds.

$w\u2192=0$ and $\xi p=1$ is a feasible solution for $SVMmanifoldslack$. Therefore, the optimal objective function is upper-bounded by $Fw\u2192=0,\xi \u2192=1=PC$. The upper bound on the number of iterations is then provided by theorem 2.

We can also bound the error in the objective function after $MCPslack$ terminates:

The lower bound on $F\u2605$ is apparent since $SVMmanifoldslack$ includes $SVMTkslack$ constraints for all $k$. Setting the slacks $\xi p=\xi MCP,p+\delta $ will make the solution feasible for $SVMmanifoldslack$ resulting in the upper bound.

## 4 Experiments

### 4.1 $Lq$ Ellipsoidal Manifolds

As an illustration of our method, we have generated $D$-dimensional $Lq$-norm ellipsoids with random radii, centers, and directions. The points on each manifold $Mp$ are parameterized as $Mp=x\u2192|x\u2192=x\u2192pc+\u2211i=1DRisiu\u2192ip\u2208RN$, where the center $x\u2192pc$ and basis vectors $u\u2192ip$ are random gaussian and $Ri$, the ellipsoidal radii, are sampled from $Unif[0.5R0,1.5R0]$ with mean $R0$. Similar to the classification task shown in Figure 1, we consider the following task: given $P$ of $D$-dimensional ellipsoids with the above radii distributions embedded in $N$ dimension, where $12P$ of the ellipsoids are labeled positive and the rest negative, find a linear hyperplane $w\u2192$ that shatters the given ellipsoids according to the labels, with maximum margin.

We compare the performance of $MCP$ to the conventional Point SVM ($SVMsimple$, $SVMslack$) with training samples drawn uniformly from the surface of the $Lq$ ellipsoids. The test example points for $MCP$ and point SVM are also drawn from the uniform distribution over the surface of each $Lq$ ellipsoid and given the same label as the binary label assigned to each ellipsoid. Performance is measured by generalization error on the task of classifying new test points from positively labeled manifolds from negatively labeled ones as a function of the total number of training samples used during learning.

For these manifolds, the separation oracle of $MCP$ returns points that minimize $ypw\u2192\xb7x\u2192pc+\u2211i=1DRisiu\u2192ip$ over the set $\u2225s\u2192\u2225q\u22641$. For norms with $q\u22651$, the solution can be expressed as $si=-(hip)1/(q-1){\u2211(hip)q/(q-1)}1/q$ where $hip=ypw\u2192\xb7ui\u2192p$. For $MCPslack$, we used an additional single margin constraint per manifold given by the center of the ellipsoids $x\u2192pc$.

We compare the generalization performance of the $MCP$ algorithm and point-wise SVM on the $L2$ ellipsoids (see Figure 3) and $L50$ ellipsoids (see Figure 4). As a linearly separable example, we use $P=10$$L2$ ellipsoids embedded in $N$ dimension, where with the parameters we use, $D=40$ and $R0=20$, the classification problem is known to be below critical manifold capacity for $N=500$ and $P=10$ and therefore linearly separable according to the recent theory of linear classification of general manifolds (Chung, Lee, & Sompolinsky, 2018). Then we test the generalization error performance of $MCPsimple$ and $SVMsimple$ for different numbers of samples used for training (see Figure 3a). To illustrate a linearly nonseparable example, we use the same set of $L2$ ellipsoids ($D=40$ and $R0=20$), except with an increased number of $L2$ ellipsoids, $P=12$, and a decreased ambient dimension $N=475$, such that the task is above the critical manifold capacity and linearly nonseparable. Then we compare the generalization error performance of $MCPslack$ simulations with point-$SVMslack$ (Figure 3b). Similarly, for $L50$ ellipsoids, $N,P,D$ were chosen such that the problem is slightly below the capacity for a separable case and above the capacity for a nonseparable case (the details are in the captions of Figure 4). The results illustrate that $MCP$ achieves a low generalization error very efficiently compared to a conventional maximum margin classifier using sampled training examples.

Another important question is how the classification task difficulty interacts with the number of samples required for convergence of $MCP$, as well as the manifold geometries. The recent theory of manifold classification (Chung, Lee, & Sompolinsky, 2016, 2018) illustrates the relationship between the critical manifold linear classification capacity $\alpha =P/N$, the task margin $\kappa $, and the manifold geometries such as dimension and size. To see the effect of the manifold geometries, we tested the dependence between the $L2$ ellipsoid properties above, $P,$$D$, $R0$, $q$ (for $Lq$), and the number of required training examples $m$ and the task margin $\kappa $ within the linearly separable regime. First, we varied the number of the ellipsoids $P$, while all the other task parameters are fixed at $N=500$, $D=40$, $R0=20$ (see Figure 3c), and varied the dimension of the ellipsoids $D$, while all the other task parameters are fixed at $N=500$, $P=10$, $R0=20$ (see Figure 3c). Then we find a regime where there is a trade-off between the number of examples required for convergence, $m$, and the task margin, $\kappa $. The task margin $\kappa $ is related to the task difficulty, because the harder the classification task is, the smaller the margin $\kappa $ is. When we vary $P$ and $D$, the trade-off between $m$ and $\kappa $ is manifested by an approximate plateau in $m\kappa 2$, except when $PD/N\u223c1$ (close to the capacity where $\kappa \u21920$). The task difficulty also depends on the size of the manifolds, and when we increase the ellipsoid scale, $R0$, $m\kappa 2$ shows very similar behavior as the increase in $P$ or $D$, showing a rapid increase when the task is easy and finding an approximate plateau for the larger $R0$, except that even in the large $R0$ regime, there is rapid drop in $m\kappa $ because even in the $R0\u2192\u221e,$ the hyperplane can orthogonalize the solution and have a nonzero asymptotic margin (see Figure 3d). The variation in the norm $q$ for $Lq$ ellipsoids shows a qualitatively similar behavior as the variation in $R0$, reflecting the fact that even when $q\u2192\u221e,$ the hyperplane can find an orthogonalizing solution and have a nonzero, asymptotic margin $\kappa $ (see Figure 4c).

### 4.2 ImageNet Object Manifolds

We also apply the $MCP$ algorithm to a more realistic class of object manifolds. Here, each object manifold is constructed from a set of affine warpings applied to a template image from the ImageNet data set (Deng et al., 2009). Figure 5a illustrates image changes along multiple axes of variation in such a manifold, which contains all combinations of changes along multiple axes. Those manifolds are parameterized by the intrinsic transformation dimensionality (i.e., the number of axes of variation) and the generated image variability (defined as the maximal displacement of the object corners, in pixels). In general, those affine transformations have 6 degrees of freedom; here, we demonstrate results for $2-D$ manifolds, utilizing only translation transformations, and $4-D$ manifolds, utilizing both translation and shear transformations as in Figure 5a. The resulting $P$ manifolds are split into dichotomies, with $12P$ manifolds considered as positive instances and the remaining $12P$ manifolds as negative instances. $MCP$ is then used to learn a binary classifier for the manifolds, and we obtain the parameter $C$ through cross-validation. We note that $MCP$ can easily be extended to multiclass problems, but only binary classification problems were used in this experiment.

We trained on $P=8$ object manifolds and used $N=500$ features throughout. At each iteration of $MCP$, a constraint-violating point on the manifolds is found using a local search among $K=5$ neighboring samples in the affine warping space. Figure 5b shows how quickly $MCP$ converges to a low generalization error when classifying manifolds with different amounts of variation.

Next, we compared the generalization performance of $MCP$ to conventional SVM on sampled points from two different feature representations of the images: in the original pixel space (as in the previous experiment) and in a V1-like representation of the same images created by applying full-wave rectification after filtering by arrays of Gabor functions (Serre, Wolf, Bileschi, Riesenhuber, & Poggio, 2007), as illustrated in Figure 6a. The test examples are created by transforming the template image with parameters drawn uniformly in the intrinsic transformation-parameter space and given the same label as the binary label assigned to each object manifold. For pixel representation, the images' grayscale value is used, and Gabor representations are created by applying a set of Gabor filters (of four orientations and four spatial scales) around multiple image locations, from which we randomly sampled features to match the number of pixels.

Figure 6b shows the results of $MCP$ on those object manifolds, showing how as manifolds are transformed from pixel to Gabor features, the problem changes from nonseparable to separable. We note that the maximal number $P$ of manifolds that are separable depends on the feature representation. Thus, $MCP$ can also be used to investigate the benefits of alternative features representations, such as those found in different areas of the visual hierarchy in the brain or in the layers of a deep neural network.

## 5 Discussion

We described and analyzed a novel algorithm, $MCP$, based on the cutting plane method for finding the maximum margin solution for classifying manifolds. We proved the convergence of $MCP$ and provided bounds on the number of iterations required. Our analysis shows that in the separable case, the algorithm finds a solution in a finite number of iterations that completely segregates the manifolds even though they consist of uncountable sets of points.

The situation is more complex when the manifolds are not separable. In that case, $MCP$ finds an approximate solution in a finite number of iterations that obey slack constraints on a per manifold basis. We consider the generalization performance of the $MCP$ solution on points randomly sampled from the manifolds and find that the solution generalizes well across all the manifold input points even though it has only been provided with a finite set of samples during the training iterations. The number of slack variables that are nonzero indicates the fraction of manifolds containing inseparable points, providing an upper bound on the generalization error.

$MCP$ is reminiscent of cutting-plane methods for structured SVMs in that its convergence does not explicitly depend on the presence of a large number of constraints. However, for $MCP$, the semi-infinate nature of the optimization problem arises even for binary classification due to the continuous manifold structure of the inputs, not from constraints on the outputs as it does for structured SVMs. A possible future extension of $MCP$ would be to handle structured output labels on manifold inputs.

Our experiments with both synthetic data manifolds and image manifolds demonstrate the efficiency of $MCP$ and superior performance in terms of generalization error compared to conventional SVMs using many virtual examples. Although the theoretical convergence bounds depend only on the margin, our numerical examples show that the empirical number of training samples required for $MCP$ depends on both the task margin and the manifold geometric properties. In particular, we have demonstrated how the algorithm performs when the dimensionalities, sizes, and shapes of the manifolds are varied. This illustrates the complex interplay in learning dynamics when the underlying manifold geometries are considered.

There is a natural extension of $MCP$ to nonlinear classifiers via the kernel trick, as all our operations involve dot products between the weight vector $w\u2192$ and manifold points $Mp(s\u2192)$. At each iteration, the algorithm would solve the dual version of the $SVMTk$ problem, which is readily kernelized. More theoretical work is needed to analyze infinite-dimensional kernels when the manifold optimization problem no longer is a QSIP but becomes a fully (doubly) infinite quadratic programming problem.

Beyond binary classification, variations of $MCP$ can also be used to solve other machine learning problems, including multiclass classification, ranking, ordinal regression, and one-class learning. We can also use $MCP$ to evaluate the computational benefits of manifold representations at successive layers of deep networks in both machine learning and brain sensory hierarchies. We anticipate using $MCP$ to help construct novel hierarchical architectures that can incrementally reformat the manifold representations through the layers for better overall performance in machine learning tasks, improving our understanding of how neural architectures can learn to process high-dimensional real-world signal ensembles and cope with a large variability due to continuous modulation of the underlying physical parameters.

## Acknowledgments

The work is partially supported by the Gatsby Charitable Foundation, the Swartz Foundation, the Simons Foundation (SCGB grant 325207), the NIH, the MAFAT Center for Deep Learning, and the Human Frontier Science Program (project RGP0015/2013). D. L. also acknowledges the support of the U.S. National Science Foundation, Army Research Laboratory, Office of Naval Research, Air Force Office of Scientific Research, and Department of Transportation.