Scalable Semi-Supervised SVM via Triply Stochastic Gradients

TL;DR

This paper introduces TSGS3VM, a triply stochastic gradient algorithm that significantly improves the scalability and efficiency of semi-supervised SVMs for large datasets, with theoretical convergence guarantees.

Contribution

It develops a novel triply stochastic gradient method for semi-supervised SVMs, addressing non-convexity and scalability issues in prior algorithms.

Findings

TSGS3VM outperforms existing methods in efficiency and scalability.

Theoretical analysis guarantees convergence to a stationary point.

Experimental results validate the effectiveness across various datasets.

Abstract

Semi-supervised learning (SSL) plays an increasingly important role in the big data era because a large number of unlabeled samples can be used effectively to improve the performance of the classifier. Semi-supervised support vector machine (S$^3$VM) is one of the most appealing methods for SSL, but scaling up S$^3$VM for kernel learning is still an open problem. Recently, a doubly stochastic gradient (DSG) algorithm has been proposed to achieve efficient and scalable training for kernel methods. However, the algorithm and theoretical analysis of DSG are developed based on the convexity assumption which makes them incompetent for non-convex problems such as S$^3$VM. To address this problem, in this paper, we propose a triply stochastic gradient algorithm for S$^3$VM, called TSGS$^3$VM. Specifically, to handle two types of data instances involved in S$^3$VM, TSGS$^3$VM samples a labeled instance and an unlabeled instance as well with the random features in each iteration to compute a triply stochastic gradient. We use the approximated gradient to update the solution. More importantly, we establish new theoretic analysis for TSGS$^3$VM which guarantees that TSGS$^3$VM can converge to a stationary point. Extensive experimental results on a variety of datasets demonstrate that TSGS$^3$VM is much more efficient and scalable than existing S$^3$VM algorithms.

Tables

Table 1. Table 1 : Comparisons of computational complexities and memory requirements of representative S 3 VM algorithms. ( n 𝑛 n is the training size, T 𝑇 T is the total number of iteration, t 𝑡 t denotes the number of outer loops and 1 < κ < 2.3 1 𝜅 2.3 1<\kappa<2.3 )

Algorithm	Reference	Method	Computational Complexity	Space Complexity
S3VMlight	Joachims (1999)	Self-labeling heuristics	$O\left(t{n}^{\kappa }\right)$	$O\left(n^2\right)$
NTS3VM	Chapelle (2007)	Gradient-based	$O\left(n^3\right)$	$O\left(n^2\right)$
BGS3VM	Le et al. (2016)	Gradient-based	$O\left(n^3\right)$	$O\left(n^2\right)$
BLS3VM	Collobert et al. (2006)	CCCP-based	$O\left(t{n}^{\kappa }\right)$	$O\left(n^2\right)$
ILS3VM	Gu et al. (2018d)	CCCP-based	$\approx O\left(T{n}^2\right)$	$O\left(n^2\right)$
TSGS3VM	Our	TSG	$O\left(m{T}^2\right)$	$O\left(T\right)$

Table 2. Table 2 : Summary of the non-convex loss functions used in S 3 VM, where H s ( ⋅ ) = max { 0 , s − ⋅ } H_{s}(\cdot)=\max\{0,s-\cdot\} , then H s ′ ​ ( ⋅ ) = 0 subscript superscript 𝐻 ′ 𝑠 ⋅ 0 H^{\prime}_{s}(\cdot)=0 , if ⋅ ≥ s \cdot\geq s else H s ′ ​ ( ⋅ ) = − 1 subscript superscript 𝐻 ′ 𝑠 ⋅ 1 H^{\prime}_{s}(\cdot)=-1 . SHG, SSHG and DA denote symmetric hinge, square SHG and a differentiable approximation to SSHG respectively.

Name	$u\left(r\right)$	$u^{\prime }\left(r\right)$
SHG	$\max \{0,1-\left|r\right|\}$
SSHG	$\frac{1}{2}\max {\{0,1-|r\left|\right\}}^2$
Ramp	$H_1\left(r\right)-H_s\left(r\right)$	$H_1^{\prime }\left(r\right)-H_s^{\prime }\left(r\right)$
DA	$\exp \left(-5r^2\right)$	$-10r\cdot \exp \left(-5r^2\right)$

Table 3. Table 3 : Datasets used in the experiments.

Dataset	Dimensionality	Samples	Source
CodRNA	8	59,535	LIBSVM
W6a	300	49749	LIBSVM
IJCNN1	22	49,990	LIBSVM
SUSY	18	5,000,000	LIBSVM
Skin	3	245,057	LIBSVM
Higgs	28	1,100,000	LIBSVM
Dota2	16	102,944	UCI
HEPMASS	28	10,500,000	UCI

Equations

$$\underset{f\in \mathcal{H}}{\min }$$

$$\underset{f\in \mathcal{H}}{\min }R(f)$$

$$k(x,x^{\prime })\approx \frac{1}{m}\sum _{i=1}^m{\varphi }_{{\omega }_i}(x){\varphi }_{{\omega }_i}(x^{\prime })$$

$$g(\cdot )=f(\cdot )+\xi (\cdot )$$

$$\xi (\cdot )=C{l}^{\prime }(f(x^l),y^l)k(x^l,\cdot )+C^{\ast }{u}^{\prime }(f(x^u))k(x^u,\cdot )$$

$$\xi (\cdot )\approx \zeta (\cdot )$$

$$=$$

$$\nabla R(f)={\mathbb{E}}_{(x^l,y^l)\in \mathcal{L}}{\mathbb{E}}_{x^u\sim P(x)}{\mathbb{E}}_{\omega }(\zeta (\cdot ))+f(\cdot )$$

$$f_{t+1}(\cdot )=f_t(\cdot )-{\gamma }_t({\zeta }_t(\cdot )+f_t(\cdot ))=\sum _{i=1}^t{a}_t^i{\zeta }_i(\cdot )$$

$$h_{t+1}(\cdot )=h_t(\cdot )-{\gamma }_t({\xi }_t(\cdot )+h_t(\cdot ))=\sum _{i=1}^t{a}_t^i{\xi }_i(\cdot )$$

$$||\nabla R(f)-\nabla R(g)|{|}_{\mathcal{H}}\le L||f-g|{|}_{\mathcal{H}},\forall f,g\in \mathcal{H}$$

$$\mathbb{E}_{x^{l},x^{u},\omega_{t}}\Big{[}\Big{|}f_{t}(x)-h_{t}(x)\Big{|}^{2}\Big{]}\leq\dfrac{D}{T^{1/2}}$$

$${\mathbb{E}}_{x^l,x^u,{\omega }_t}[||\nabla R(h_t)|{|}_{\mathcal{H}}^2]\le \frac{E}{T^{1/4}}+\frac{F}{T^{3/4}}$$

$$\mathbb{E}_{x^{l},x^{u},\omega_{t}}\Big{[}\Big{|}f_{t}(x)-h_{t}(x)\Big{|}^{2}\Big{]}\leq B^{2}_{1,t+1}$$

$$|W_i(x)|$$

$$\le c_i=|a_t^i|(|{\zeta }_i(x)|+|{\xi }_i(x)|)$$

$$\displaystyle=\quad|a_{t}^{i}|\big{[}|Cl^{\prime}(f(x_{i}^{l}),y_{i}^{l})k(x_{i}^{l},x)+C^{*}u^{\prime}(f(x_{i}^{u}))k(x_{i}^{u},x)|$$

$$+|C{l}^{\prime }(f(x_i^l),y_i^l){\varphi }_{{\omega }_i}(x_i^l){\varphi }_{{\omega }_i}(x)$$

$$\displaystyle\quad+C^{*}u^{\prime}(f(x_{i}^{u}))\phi_{\omega_{i}}(x_{i}^{l})\phi_{\omega_{i}}(x)|\big{]}$$

$$\displaystyle\leq\quad|a_{t}^{i}|\big{[}(CM^{l}+C^{*}M^{u})(\sqrt{\kappa}+\sqrt{\phi})\big{]}$$

$$=M(\sqrt{\kappa }+\sqrt{\varphi })|a_t^i|$$

$$B_{1,t+1}^2$$

$$\le M^2(\sqrt{\kappa }+\sqrt{\varphi }{)}^{2}T\frac{{\theta }^2}{T^{3/2}}$$

$$\le M^2(\sqrt{\kappa }+\sqrt{\varphi }{)}^2\frac{{\theta }^2}{T^{1/2}}$$

$$g_t$$

$$=C{l}^{\prime }(f_t(x_t^l),y_t^l)k(x_t^l,\cdot )$$

$$+C^{\ast }{u}^{\prime }(f_t(x_t^u))k(x_t^u,\cdot )+h_t$$

$${\hat{g}}_t$$

$$=C{l}^{\prime }(h_t(x_t^l),y_t^l)k(x_t^l,\cdot )$$

$$+C^{\ast }{u}^{\prime }(h_t(x_t^u))k(x_t^u,\cdot )+h_t$$

$$\nabla R(h_t)$$

$$={\mathbb{E}}_{x^l,x^u}[C{l}^{\prime }(h_t(x_t^l),y_t^l)k(x_t^l,\cdot )$$

$$+C^{\ast }{u}^{\prime }(h_t(x_t^u))k(x_t^u,\cdot )]+h_t$$

$$R(h_{t+1})$$

$$\le R(h_t)+⟨\nabla R(h_t),h_{t+1}-h_t⟩+\frac{L}{2}||h_{t+1}-h_t|{|}_{\mathcal{H}}^2$$

$$=R(h_t)-\gamma ⟨\nabla R(h_t),g_t⟩+\frac{L{\gamma }^2}{2}||g_t|{|}_{\mathcal{H}}^2$$

$$=R(h_t)-\gamma ⟨\nabla R(h_t),g_t-{\hat{g}}_t+{\hat{g}}_t-\nabla R(h_t)$$

$$+\nabla R(h_t)⟩+\frac{L{\gamma }^2}{2}||g_t|{|}_{\mathcal{H}}^2$$

$$=R(h_t)-\gamma ||\nabla R(h_t)|{|}_{\mathcal{H}}^2+\gamma ⟨\nabla R(h_t),{\hat{g}}_t-g_t⟩$$

$$+\gamma ⟨\nabla R(h_t),\nabla R(h_t)-{\hat{g}}_t⟩+\frac{L{\gamma }^2}{2}||g_t|{|}_{\mathcal{H}}^2$$

$$\frac{1}{T}\sum _{t=1}^T\gamma ||\nabla R(h_t)|{|}_{\mathcal{H}}^2$$

$$\displaystyle\leq\quad\frac{1}{T}\big{[}R(h_{1})-R(h_{T+1})+\sum_{t=1}^{T}\gamma\langle\nabla R(h_{t}),\hat{g}_{t}-g_{t}\rangle$$

Full text

1 Introduction

Semi-supervised learning (SSL) plays an increasingly important role in the big data era because a large number of unlabeled samples can be used effectively to improve the performance of the classifier. Semi-supervised support vector machine (S3VM) Bennett and Demiriz (1999) is one of the most appealing methods for SSL. Specifically, S3VM enforces the classification boundary to go across the less-dense regions in the reproducing kernel Hilbert space (RKHS), while keeping the labeled data correctly classified. Unfortunately, this will lead to a non-convex optimization problem. It is well known that solving a non-convex optimization problem is normally difficult than solving a convex one like standard support vector machine. Under this arduous challenge, a wide spectrum of methods for S3VM have been proposed in the last two decades. Generally speaking, these methods can be roughly divided into three groups, i.e., methods with self-labeling heuristics, concave-convex procedure (CCCP) methods and gradient-based methods. We give a brief review of these representative S3VM methods in Section 2 and Table 1.

Unfortunately, these traditional S3VM methods are inefficient due to increased complexity introduced by the cost of kernel computation as well as non-convexity. Specifically, the kernel matrix needs $O(n^{2}d)$ operations to be calculated and $O(n^{2})$ memory to be stored, where $n$ denotes the size of training samples and $d$ denotes dimension of the data Gu et al. (2018b). Essentially, gradient-based S3VM methods have $O(n^{3})$ complexity due mainly to the operations on the kernel matrix. Even though a convex kernel problem can be solved by a state-of-the-art solver (e.g. LIBSVM), $O(n^{\kappa})$ computation is still needed where $1<\kappa<2.3$ Chang and Lin (2011). While to handle the non-convexity of S3VM, the methods using self-labeling heuristics and CCCP-based algorithms need to solve multiple convex sub-problems to guarantee that they finally converge Yuille and Rangarajan (2002). As a result, these methods scale as $O(tn^{\kappa})$, where $t$ denotes the number of solving sub-problems. We summarize the computational complexities and memory requirements of the representative S3VM methods in Table 1. As pointed in Gu et al. (2018d), scaling up S3VM is still an open problem.

Recently, a novel doubly stochastic gradient (DSG) method Dai et al. (2014) was proposed to achieve efficient and scalable training for kernel methods. Specifically, in each iteration, DSG computes a doubly stochastic gradient by sampling a random data sample and the corresponding random features to update the solution. Thus, DSG avoids computing and storing a kernel matrix, while enjoying nice computational and space complexities. Xie et al. Xie et al. (2015) used DSG to scale up nonlinear component analysis. To the best of our knowledge, Xie et al. (2015) is the only work based on DSG to solve a non-convex problem.

However, existing algorithms and theoretical analysis of DSG cannot be applied to S3VM due to the following two reasons. 1) Multiple data distributions: S3VM minimizes the training errors coming from two different sources. One is the expected error on the unlabeled data, and the other one is the mean error on the labeled data whose size is normally significantly smaller than the one of unlabeled data. However, DSG only considers the expected error on the labeled data. 2) Non-convexity analysis: The theoretical analysis in Xie et al. (2015) is based on a strong assumption (i.e., the initialization needs to be close to the optimum). However, such an assumption is rarely satisfied in practice. Besides, they focus on the nonlinear component analysis instead of general non-convex problems. Thus, it is infeasible to extend the analysis of Xie et al. (2015) to S3VM.

To address this challenging problem, we first propose a new and practical formulation of S3VM. Then, we develop a new triply stochastic gradient algorithm (TSGS3VM) to solve the corresponding optimization problem. Specifically, to handle two types of data instances involved in S3VM, TSGS3VM samples a labeled instance and an unlabeled instance as well with their random features in each iteration to compute a triply stochastic gradient (TSG). We then use the TSGs to iteratively update the solution. A critical question is whether and how fast this optimization process with multiple randomness would converge. In addressing this concern, we establish new theoretic analysis for TSGS3VM which guarantees that TSGS3VM can converge to a stationary point with a sublinear convergence rate for a general non-convex learning problem under weak assumptions. Extensive experimental results demonstrate the superiority of TSGS3VM.

Novelties. We summary the main novelties of this paper as follows.

To scale up S3VM, we propose a practical formulation of S3VM and develop a novel extension of DSG that could solve optimization problems with multiple data sources. 2. 2.

We have established the new theoretic analysis of TSGS3VM algorithm for a general non-convex learning problem which guarantees its convergence to a stationary point. To the best of our knowledge, it is the first work offering non-convex analysis for DSG-like algorithms without initialization assumption.

2 Related Works

We give a brief review of kernel approximation methods as well as the representative S3VM methods.

Kernel Approximation.

There are many kernel approximation methods proposed to address the scalability issue of kernel methods. For instance, low-rank factors are used to approximate the kernel matrix in Drineas and Mahoney (2005). Rahimi & Recht Rahimi and Recht (2008) provided another method that uses random features to approximate the map function explicitly. However, as analyzed in Drineas and Mahoney (2005); Lopez-Paz et al. (2014), the rank for low-rank and the number of random features need to be $O(n)$ to obtain a good generalization ability. To further improve the random features method, Dai et al. Dai et al. (2014) proposed DSG descent algorithm. Carratino et al. Carratino et al. (2018) proved that DSG only need $O(\sqrt{n})$ random features to obtain a good result. However, existing DSG methods Li et al. (2017); Gu et al. (2018c); Shi et al. (2019) can not be used for S3VM as discussed previously.

S3VM Methods.

As mentioned above, traditional S3VM methods can be roughly divided into three types, i.e., the method of self-labeling heuristics, the concave-convex procedure (CCCP) method, and the gradient-based method. For the method of self-labeling heuristics, Joachims Joachims (1999) proposed a S3VMlight algorithm which uses self-labeling heuristics for labeling the unlabeled data, then iteratively solve this standard SVM until convergence. CCCP-based methods were proposed to solve S3VM in Chapelle and Zien (2005); Wang et al. (2007); Yu et al. (2019). The basic principle of CCCP is to linearize the concave part of S3VM’s objective function around a solution obtained in the current iteration so that sub-problem is convex. Then the CCCP framework solves a sequence of the convex sub-problem iteratively until decision variable converges. Based on CCCP framework, Gu et al. Gu et al. (2018d) proposed an incremental learning method for S3VM which is suitable for the online scenario. For gradient-based methods, Chapelle and Zien Chapelle and Zien (2005) approximate the kernel matrix $K$ using low-rank factors, then using gradient descent to solve S3VM on the low-rank matrix. BGS3VM Le et al. (2016) uses budgeted SGD to limit the model size to two predefined budgets $B_{l}$ and $B_{u}$.

3 Preliminaries

In this section, we first give a general non-convex learning problem for S3VM, and then give a brief review of random feature approximation.

3.1 S3VM Optimization Formulation

Given the training dataset $\cal X$ constituted with $n^{l}$ labeled examples $\mathcal{L}:=\{({x}_{i},y_{i})\}_{i=1}^{n^{l}}$ and $n^{u}$ unlabeled examples $\mathcal{U}:=\{{x}_{i}\}_{i=n^{l}+1}^{n}$, where $n=n^{l}+n^{u}$, ${x_{i}}\in\mathbb{R}^{d}$, and $y_{i}\in\{1,-1\}$. Traditional S3VM solves the following problem.

[TABLE]

where $C$ and $C^{*}$ are regularization parameters, $||\cdot||_{\cal H}$ denotes the norm in RKHS, $l(r,v)=\max(0,1-vr)$ is the hinge loss, its subgradient $l^{\prime}(r,v)=0$, if $rv\geq 1$, else $l^{\prime}(r,v)=-v$, $u(r)$ is the non-convex loss function which enforce unlabeled data away from the discrimination hyperplane. We summarize the commonly used non-convex S3VM losses and its subgradient $u^{\prime}(r)$ in Table 2.

For S3VM problems, however, the volumes of labeled and unlabeled data are usually quite different. Because of the labeling cost, the labeled dataset is often very small, while a large amount of unlabeled data can be obtained relatively easily. Taking this into consideration, we propose to solve a novel S3VM formulation as follows.

[TABLE]

where $P(x)$ denotes the target data distribution. Notice that we use the empirical mean error on the labeled dataset, while using the expected error on the whole distribution for the unlabeled data.

3.2 Random Feature Approximation

Random feature is a powerful technique to make kernel methods scalable. It uses the intriguing duality between kernels and stochastic processes. Specifically, according to the Bochner theorem Wendland (2004), for any positive definite PD kernel $k(\cdot,\cdot)$, there exists a set $\Omega$, a probability measure $\mathbb{P}$ and a random feature map $\phi_{\omega}(x)$, such that $k(x,x^{\prime})=\int_{\Omega}\phi_{\omega}(x)\phi_{\omega}(x^{\prime})d\mathbb{P}(\omega)$. In this way, the value of the kernel function can be approximated by explicitly computing random features $\phi_{\omega}(x)=[\frac{1}{\sqrt{m}}\phi_{\omega_{1}}(x),\frac{1}{\sqrt{m}}\phi_{\omega_{2}}(x),\cdots,\frac{1}{\sqrt{m}}\phi_{\omega_{m}}(x)]$, i.e.,

[TABLE]

where $m$ is the number of random features. Using Gaussian RBF kernel as a concrete example, it yields a Gaussian distribution $\mathbb{P}(\omega)$ over random feature maps of Fourier basis functions $\phi_{\omega_{i}}(x)=\sqrt{2}cos({\omega_{i}^{T}x+b})$ to compute its feature mapping, where $\omega_{i}$ is drawn from $\mathbb{P}(\omega)$ and $b$ is drawn uniformly form $[0,2\pi]$. Moreover, many random feature construction methods have been proposed for various kernels, such as dot-product kernels and Laplacian kernels.

The theory of RKHS provides a rigorous mathematical framework for studying optimization problems in the functional space. Specifically, we know that every PD kernel $k(x,x^{\prime})$ has a corresponding RKHS $\mathcal{H}$. An RKHS $\mathcal{H}$ has the reproducing property, i.e., $\forall x\in\mathcal{X},\forall f\in\mathcal{H}$, we always have $\langle f(\cdot),k(x,\cdot)\rangle_{\mathcal{H}}=f(x)$. Besides, functional gradient in RKHS $\mathcal{H}$ can be computed as $\nabla f(x)=k(x,\cdot)$ and $\nabla||f||^{2}_{\mathcal{H}}=2f$.

4 Triply Stochastic S3VM

The above section has introduced the basic theoretic tools for triply stochastic functional gradient descent. Now we introduce how to utilize these tools to solve the S3VM problem.

4.1 Triply Stochastic Gradient

From Eq. (3.1), it is not hard to notice that $R(f)$ involves two different data sources. Taking into consideration the distribution of random features $\omega\sim\mathbb{P}(\omega)$ would give us three sources of possible randomness. Here we will show how to explicitly compute the stochastic gradient with these three sources of randomness.

Stochastic Functional Gradients.

Naturally, to iteratively update $f$ in a stochastic manner, we need to sample instances from the labeled dataset as well as the whole distribution. Different from DSG, we here randomly sample a pair of data points, from the labeled and the unlabeled data distributions, respectively. Then we can obtain stochastic functional gradients for $R(f)$ with these two data points as follow,

[TABLE]

where $\xi(\cdot)$ is the gradient contributed by the loss from both labeled and unlabeled data. It can be computed using the chain rule

[TABLE]

where $x^{l}$, $x^{u}$ are sampled from the labeled dataset and unlabeled distribution $P(x)$ respectively. Next we will plugging the random feature approximation technique described in the previous section.

Random Feature Approximation.

According to Eq. (2), when we use stochastically generated random feature $\omega$, we can further approximate $\xi(\cdot)$ as:

[TABLE]

note that $\xi(\cdot)=\mathbb{E}_{\omega}[\zeta(\cdot)]$. This leads to an unbiased estimator of the original functional gradient with three layers of stochasticity, i.e.,

[TABLE]

Since three random events occur per iteration, i.e. $x^{l}$, $x^{u}$, $\omega$, we call our approximate functional gradient as triply stochastic functional gradient.

Update Rules.

In the $t$-th iteration, the triply stochastic (functional) gradient update rule for $f$ is:

[TABLE]

where $\gamma$ denotes the step size and the initial value $f_{1}(\cdot)=0$. It is straight forward to calculate that $a_{t}^{i}=-\gamma_{i}\prod_{k=i+1}^{t}(1-\gamma_{k})$. Ideally, if we could somehow compute the stochastic (functional) gradients $\xi_{j}(\cdot)$, the update rule becomes:

[TABLE]

where we have used $h_{t+1}$ instead of $f_{t+1}$ to distinguish from the triply stochastic (functional) gradient update rule and $h_{1}(\cdot)=0$. However, to avoid the expense of kernel computation, our algorithm will use the triply stochastic update rule Eq. (7) instead of Eq. (8).

4.2 Algorithm

Based on the above triply stochastic gradient update rules (7), we provide the TSGS3VM training and prediction procedures in Algorithms 1 and 2 receptively. Notice that directly computing all the random features still needs a large amount of memory. Following the pseudo-random number generators setting of Dai et al. (2014), our random feature generator is initialized by a predefined seed according to iteration. Thus, TSGS3VM does not need to save the random feature matrix which makes it more memory friendly. In the $i$-th iteration, our method will execute the following steps.

Sample data pair (lines 2-3 in Algorithm 1): Stochastically sample a labeled sample $(x^{l}_{i},y^{l}_{i})$ and an unlabeled sample $x^{u}_{i}$ from different distribution respectively. 2. 2.

Sample random features (line 4 in Algorithm 1): Stochastically sample $\omega^{i}\sim\mathbb{P}(\omega)$ with seed $i$ and generate random features. 3. 3.

Update coefficients (lines 5-8 in Algorithm 1): Evaluate function value and update $f$ according to Eq. (7).

Remark 1

For each iteration, TSGS3VM needs $O(mT)$ operations to evaluate function value, since evaluating the function value needs generating $m$ random features ($O(m)$) for $T$ times. Thus, the total computational complexity of TSGS3VM is $O(mT^{2})$. Due to the use of random features and pseudo-random method, TSGS3VM only requires $O(T)$ memory, where $T$ is the iteration number.

5 Theoretical Guarantees

We follow the common goal of non-convex analysis Ghadimi and Lan (2013); Gu et al. (2018a); Huo et al. (2018) to bound $\mathbb{E}||\nabla R(f)||^{2}$, which means that the objective function will converge (in expectation) to a stationary point $f_{*}$. When we use the hypothetical update rule (8), $h_{t}$ will always be inside of $\cal H$. However, because we could only use random features to approximate $h_{t}$ with $f_{t}$, we face the risk that functional $f_{t}$ could be outside of $\cal H$. As a consequence, $\mathbb{E}||\nabla R(f)||^{2}_{\cal H}=0$ is not the stationary point of the objective function (3.1). From Eq. (7) and Eq. (8), it is obvious that every update of $h_{t}$ happens implicitly with an update of $f_{t}(x)$. According to this relationship, we proposed to divide the analysis in two parts. As illustrated in Fig. 1, for a general non-convex optimization problem $R(h)$, we prove that the $h_{t+1}$ converges to a stationary point $f_{*}$ (i.e., $\mathbb{E}||\nabla R(h_{t+1})||^{2}_{\cal H}<\epsilon_{1}$) firstly. Then we prove that $f_{t+1}(x)$ keeps close to its hypothetic twin $h_{t+1}(x)$ for any $x\in\cal X$ (i.e., $|f_{t+1}(x)-h_{t+1}(x)|^{2}<\epsilon_{2}$).

Our analysis is built upon the following assumptions which are standard for the analysis of non-convex optimization and DSG Dai et al. (2014).

Assumption 1

(Lipschitzian gradient) The gradient function $\nabla R(f)$ is Lipschitzian, that is to say

[TABLE]

Assumption 2

(Lipschitz continuity) $l(r,v)$ is $L^{\prime}$-Lipschitz continuous in terms of its 1st argument. $u(r,v)$ is $U^{\prime}$-Lipschitz continuous in terms of its 1st argument. We further denote $M^{\prime}=CL^{\prime}+C^{*}U^{\prime}$.

Assumption 3

(Bound of derivative) The derivatives are bounded: $|l^{\prime}|<M^{l}$ and $|u^{\prime}|<M^{u}$, where $l^{\prime}$ and $u^{\prime}$ is the derivative of $l(r,v)$ and $u(r)$ w.r.t. the 1st argument respectively. We further denote $M=CM^{l}+C^{*}M^{u}$.

Assumption 4

(Bound of kernel and random features) We have an upper bound for the kernel value, $k(x,x^{\prime})\leq\kappa$. There is an upper bound of random feature norm, i.e., $|\phi_{\omega}(x)\phi_{\omega}(x^{\prime})|\leq\phi$.

Suppose the total number of iterations is $T$, we introduce our main theorems as below. All the detailed proofs are provided in our Appendix.

Theorem 1

For any $x\in\cal X$, fix $\gamma=\frac{\theta}{T^{3/4}}$ with $0<\theta\leq T^{3/4}$, we have

[TABLE]

where $D=\theta^{2}M^{2}(\sqrt{\kappa}+\sqrt{\phi})^{2}$.

Remark 2

The error between $f_{t+1}$ and $h_{t+1}$ is mainly induced by random features. Theorem 1 shows that this error has the convergence rate of $O(1/\sqrt{T})$ with proper step size.

Theorem 2

For fixed $\gamma=\frac{\theta}{T^{3/4}}$, $0<\theta\leq T^{3/4}$, we have that

[TABLE]

where $E=\frac{1}{\theta}[R(h_{1})-R^{*}]+\theta M^{2}M^{\prime}(\sqrt{\kappa}+\sqrt{\phi})\kappa,F=2\theta M^{2}L\kappa$, $R^{*}$ denotes the optimal value of (3.1).

Remark 3

Instead of using the convexity assumption in Dai et al. (2014), Theorem 2 uses Lipschitzian gradient assumption to build the relationship between gradients and the updating functions $h_{t+1}$. Thus, we can bound each error term of $\mathbb{E}_{x^{l},x^{u},\omega_{t}}[||\nabla R(h_{t})||^{2}_{\cal H}]$ as shown in Appendix. Note that compared to the strong assumption (i.e., the good initialization) used in Xie et al. (2015), the assumptions used in our proofs are weaker and more realistic.

6 Experiments and Analysis

In this section, we will evaluate the practical performance of TSGS3VM when comparing against other state-of-the-art solvers.

6.1 Experimental Setup

To show the advantage our TSGS3VM for large-scale S3VM learning, we conduct the experiments on large scale datasets to compare TSGS3VM with other state-of-the-art algorithms in terms of predictive accuracy and time consumption. Specifically, the compared algorithms in our experiments are summarized as follows111BLS3VM and S3VMlight can be found in http://pages.cs.wisc.edu/ jerryzhu/ssl/software.html.

BLS3VM Collobert et al. (2006): The state-of-art S3VM algorithm based on CCCP and SMO algorithm Cai and Cherkassky (2012). 2. 2.

S3VMlight Joachims (1999): The implementation in the popular S3VMlight software. It is based on the local combinatorial search guided by a label switching procedure. 3. 3.

BGS3VMLe et al. (2016): Our implementation of BGS3VM in MATLAB. 4. 4.

FRS3VM: Standard SGD with fixed random features. 5. 5.

TSGS3VM: Our proposed S3VM algorithm via triply stochastic gradients.

Implementation.

We implemented the TSGS3VM algorithm in MATLAB. For the sake of efficiency, our TSGS3VM implementation also uses a mini-batch setting. We perform experiments on Intel Xeon E5-2696 machine with 48GB RAM. The Gaussian RBF kernel $k(x,x^{\prime})=\exp(-\sigma||x-x^{\prime}||^{2})$ and the loss function $u=\max\{0,1-|r|\}$ was used for all algorithms. 5-fold cross-validation was used to determine the optimal settings (test error) of the model parameters (the regularization factor C and the Gaussian kernel parameter $\sigma$), the parameters $C^{*}$ was set to $C\frac{n^{l}}{n^{u}}$. Specifically, the unlabeled dataset was divided evenly to 5 subsets, where one of the subsets and all the labeled data are used for training, while the other 4 subsets are used for testing. Parameter search was done on a 7$\times$7 coarse grid linearly spaced in the region $\{\log_{10}C,\log_{10}\sigma)|-3\leq\log_{10}C\leq 3,-3\leq\log_{10}\sigma\leq 3\}$ for all methods. For TSGS3VM, the step size $\gamma$ equals $\frac{1}{\eta}$, where $0\leq\log_{10}{\eta}\leq 3$ is searched after $C$ and $\sigma$. Besides, the number of random features is set to be $\lceil\sqrt{n}\rceil$ and the batch size is set to 256. The test error was obtained by using these optimal model parameters for all the methods. To achieve a comparable accuracy to our TSGS3VM, we set the minimum budget sizes $B_{l}$ and $B_{u}$ as $100$ and $0.2*n_{u}$ respectively for BG$S^{3}$VM. We stop TSGS3VM and BG$S^{3}$VM after one pass over the entire dataset. We stop FRS3VM after 10 pass over the entire dataset to achieve a comparable accuracy. All results are the average of 10 trials.

Datasets.

Table 3 summarizes the 8 datasets used in our experiments. They are from LIBSVM222https://www.csie.ntu.edu.tw/ cjlin/libsvmtools/datasets/ and UCI333http://archive.ics.uci.edu/ml/datasets.html repositories. Since all these datasets are originally labeled, we intentionally randomly sample 200 labeled instances and treat the rest of data as unlabeled to make a semi-supervised learning setting.

6.2 Experimental Results

Fig. 2 shows the test error v.s. the training size for different algorithms. The results clearly show that TSGS3VM runs much faster than other methods. Specifically, Figs. 2d and 2h confirm the high efficiency of TSGS3VM even on the datasets with one million samples. Besides, TSGS3VM requires low memory benefiting from pseudo-randomness for generating random features, while BLS3VM and S3VMlight would be often out of memory on large scale datasets.

Fig. 3 shows the test error of different methods. The results were obtained at the optimal hyper-parameters for different algorithms. From the figure, it is clear that TSGS3VM achieves similar generalization performance as that of BLS3VM, S3VMlight, and BGS3VM methods which confirm that TSGS3VM converge well in practice. Besides, TSGS3VM achieves better generalization performance than FRS3VM, because TSGS3VM has the advantage that it would automatically use more and more random features (for each data $x$) as the number of iterations increases.

Based on these results, we conclude that TSGS3VM is much more efficient and scalable than these algorithms while retaining the similar generalization performance.

7 Conclusion

In this paper, we provide a novel triply stochastic gradients algorithm for kernel S3VM to make it scalable. We establish new theoretic analysis for TSGS3VM which guarantees that TSGS3VM can efficiently converge to a stationary point for a general non-convex learning problem under weak assumptions. As far as we know, TSGS3VM is the first work that offers non-convex analysis for DSG-like algorithm without a strong initialization assumption. Extensive experimental results on a variety of benchmark datasets demonstrate the superiority of our proposed TSGS3VM.

Acknowledgments

H.H. was partially supported by U.S. NSF IIS 1836945, IIS 1836938, DBI 1836866, IIS 1845666, IIS 1852606, IIS 1838627, IIS 1837956. B.G. was partially supported by the National Natural Science Foundation of China (No: 61573191), and the Natural Science Foundation (No. BK20161534), Six talent peaks project (No. XYDXX-042) in Jiangsu Province.

Appendix A Proof of Theorem 1

To proof theorem 1, we first give lemma 1 as follows

Lemma 1

For any $x\in\cal X$, consider a fix step size $\gamma$, and $0<\gamma\leq 1$, we have that

[TABLE]

where $B^{2}_{1,t+1}:=M^{2}(\sqrt{\kappa}+\sqrt{\phi})^{2}t\gamma^{2}$, and $B_{1,1}=0$.

Proof. We denote $W_{i}(x)=W_{i}(x;x_{i}^{l},x_{i}^{u},\omega_{i})=a_{t}^{i}(\zeta^{i}(x)-\xi^{i}(x))$. Based on the definition and assumptions in main body, $W_{i}(x)$ is bounded as follows

[TABLE]

Based on the definition of $a_{t}^{t}$, $|a_{t}^{t}|\leq\gamma$, and for any $i$ we have $|a_{t}^{i}|\leq\gamma\prod_{j=i+1}^{t}(1-\gamma)\leq\gamma$ due to $0<\gamma\leq 1$. Consequently, $\sum_{i=1}^{t}|a_{t}^{i}|^{2}\leq t\gamma^{2}$. Then we have \mathbb{E}_{x^{l}_{t},x^{u}_{t},\omega_{t}}\Big{[}\Big{|}f_{t}(x)-h_{t}(x)\Big{|}^{2}\Big{]}\leq M^{2}(\sqrt{\kappa}+\sqrt{\phi})^{2}\sum_{i=1}^{t}|a_{t}^{i}|^{2}\leq M^{2}(\sqrt{\kappa}+\sqrt{\phi})^{2}t\gamma^{2}. We obtain the Lemma 1. Taking $\gamma=\frac{\theta}{T^{3/4}}$, we have

[TABLE]

then we obtain theorem 1.

Appendix B Proof of Theorem 2

Proof For the sake of simple notations, let us first denote the following three different gradient terms, which are

[TABLE]

Besides, we use $\mathbb{E}$ to denotes $\mathbb{E}_{x^{l}_{t},x^{u}_{t},\omega_{t}}$ for simplicity sometimes. Similar as Ghadimi and Lan (2013); Reddi et al. (2016), using the assumption 1 and $h_{t+1}=h_{t}-\gamma g_{t},\forall t\geq 1$, for $t=1,\cdots,T$ we have

[TABLE]

Summing up the above inequalities from and re-arranging the terms, we obtain

[TABLE]

where $R^{*}$ is the optimal value of $R(h_{t})$ and the last inequality follows from the fact that $R(h_{T+1})\geq R^{*}$. Taking expectations on both sides we have

[TABLE]

Let us denote $\mathcal{H}_{t}=\sqrt{||\nabla R(h_{t})||^{2}_{\cal H}},\mathcal{M}_{t}=||g_{t}||^{2}_{\cal H},\mathcal{N}_{t}=\langle\nabla R(h_{t}),\nabla R(h_{t})-\hat{g}_{t}\rangle$,$\mathcal{R}_{t}=\langle\nabla R(h_{t}),\hat{g}_{t}-g_{t}\rangle$. From lemma 2, we have the bound as follows

[TABLE]

Applying these bounds we give above leading to the refined recursion as follows

[TABLE]

Let $\gamma=\frac{\theta}{{T^{3/4}}}$, we have

[TABLE]

Thus, we complete the proof.

Appendix C Lemma 2

Lemma 2

In this lemma, we prove the inequalities (18)-(21)

Proof Similar to Dai et al. (2014), given the definitions of $\mathcal{M}_{t},\mathcal{H}_{t},\mathcal{N}_{t},\mathcal{R}_{t}$ we have

(1) $\mathcal{M}_{t}\leq 4\kappa M^{2}$;

This is because $\mathcal{M}_{t}=||g_{t}||^{2}_{\cal H}=||\xi_{t}+h_{t}||_{\cal H}^{2}\leq(||\xi_{t}||_{\cal H}+||h_{t}||_{\cal H})^{2}$. We have

[TABLE]

where the first inequality because triangle inequality, and from lemma 3 we have $||h_{t}||_{\cal H}\leq{\kappa^{1/2}M}$. Applying these bounds leads to $\mathcal{M}_{t}\leq 4\kappa M^{2}$

(2) $\mathbb{E}_{x^{l}_{t},x^{u}_{t},\omega_{t}}[\mathcal{H}_{t}]^{2}\leq 4\kappa M^{2}$; This is because

[TABLE]

where $||\mathbb{E}_{x^{l}_{t},x^{u}_{t},\omega_{t}}[\hat{\xi}_{t}]||_{\cal H}\leq\kappa^{1/2}M$ according to (C), and from lemma 3 we have $||h_{t}||_{\cal H}\leq{\kappa^{1/2}M}$. Applying these bounds leads to $\mathbb{E}_{x^{l}_{t},x^{u}_{t},\omega_{t}}[\mathcal{H}_{t}]^{2}\leq 4\kappa M^{2}$

(3) $\mathbb{E}_{x^{l}_{t},x^{u}_{t},\omega_{t}}[\mathcal{N}_{t}]=0$; This is because

[TABLE]

(4) $\mathbb{E}_{x^{l}_{t},x^{u}_{t},\omega_{t}}[\mathcal{R}_{t}]=\leq\kappa MM^{\prime}B_{1,t}$; This is because

[TABLE]

[TABLE]

where the first and third inequalities are due to Cauchy-Schwarz Inequality, the second inequality is due to $L^{\prime}$-Lipschitz continuity of $l^{\prime}(\cdot,\cdot)$ and $U^{\prime}$-Lipschitz continuity of $u^{\prime}(\cdot,\cdot)$, the forth inequality is due to lemma 1 and fifth inequality is due to the bound of $\mathbb{E}_{x^{l}_{t},x^{u}_{t},\omega_{t}}[\mathcal{H}_{t}]^{2}$ we give above.

Appendix D Lemma 3

Lemma 3

For any $t=1\cdots T$, we have $||h_{t}||\leq{\kappa^{1/2}M}$

Proof For $t=1$, according to the definition of $h_{t}$ we have $h_{1}=0,||h_{1}||_{\cal H}=0\leq{\kappa^{1/2}M}$. For any $t=1\cdots T-1$ if we have $||h_{t}||_{\cal H}\leq{\kappa^{1/2}M}$, then according to the definition of $h_{t}$ we have

[TABLE]

The first inequality is because triangle inequality, the second inequality is because the assumption bound of $h_{t}$ and the bound of $\xi_{t}(\cdot)$ in (C). Now we have lemma 3.

Appendix E Convergence curves related to iterations

We report the convergence curve related to iterations of TSGS3VM in Fig 4. Fig 4 shows that TSGS3VM usually converge to a good result in a few iterations (about 64-128). Note that, similar to DSG, our TSGS3VM implementation also uses a mini-batch setting, where the batch size is set to 256. Thus, in each iteration, TSGS3VM randomly sample 256 instances to compute the TSG.