Scalable Semi-Supervised SVM via Triply Stochastic Gradients
Xiang Geng Bin Gu Xiang Li Wanli Shi Guansheng Zheng Heng Huang
cs.LG stat.ML

	
Anonymity Mixes as (Partial) Assembly Queues:

Modeling and Analysis
    
  Mehmet Fatih Aktaş and Emina Soljanin
  Department of Electrical and Computer Engineering, Rutgers University 

Email: {mehmet.aktas, emina.soljanin}@rutgers.edu

    December 30, 2023
=========================================================================================================================================================================


	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^3VM) is one of the most appealing methods for SSL, but scaling up S^3VM 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^3VM. To address this problem, in this paper, we propose a triply stochastic gradient algorithm for S^3VM, called TSGS^3VM. Specifically, to handle two types of data instances involved in S^3VM, TSGS^3VM 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^3VM which guarantees that TSGS^3VM can converge to a stationary point. Extensive experimental results on a variety of datasets demonstrate that TSGS^3VM is much more efficient and scalable than existing S^3VM algorithms.




§ 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 (S^3VM) <cit.> is one of the most appealing methods for SSL.

Specifically, S^3VM 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 S^3VM 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 S^3VM methods in Section <ref> and Table <ref>.


Unfortunately, these traditional S^3VM 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^2d) 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 <cit.>. Essentially, gradient-based S^3VM 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^κ) computation is still needed where 1<κ<2.3 <cit.>.
While to handle the non-convexity of S^3VM, the methods using self-labeling heuristics and CCCP-based algorithms need to solve multiple convex sub-problems to guarantee that they finally converge <cit.>. As a result, these methods scale as O(tn^κ), where t denotes the number of solving sub-problems.







We summarize the computational complexities and memory requirements of the representative S^3VM methods in Table <ref>. 

As pointed in <cit.>, scaling up S^3VM is still an open problem.

Recently, a novel doubly stochastic gradient (DSG)  method <cit.> 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. xie2015scale used  DSG to scale up nonlinear component analysis. To the best of our knowledge, <cit.> 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 S^3VM due to the following two reasons.
1) Multiple data distributions: S^3VM  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 <cit.> 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 <cit.> to  S^3VM.



To address this challenging problem, we first propose a new and practical formulation of S^3VM.
Then, we develop a new triply stochastic gradient algorithm (TSGS^3VM) to solve the corresponding optimization problem. Specifically, to handle two types of data instances involved in S^3VM, TSGS^3VM 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 TSGS^3VM which guarantees that TSGS^3VM 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 TSGS^3VM.

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

	
  * To scale up S^3VM, we propose a practical formulation of S^3VM and develop a novel extension of DSG that could solve optimization problems with multiple data sources.
	
  * We have established the new theoretic analysis of TSGS^3VM 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.




§ RELATED WORKS


We give a brief review of  kernel approximation methods as well as the representative S^3VM 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

<cit.>.

Rahimi & Recht rahimi2008random provided another method that uses random features to approximate the map function explicitly.

However, as analyzed in <cit.>, 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. dai2014scalable proposed DSG descent algorithm.

Carratino et al. carratino2018learning proved that DSG only need O(√(n)) random features to obtain a good result.
However, existing DSG methods <cit.> can not be used for S^3VM as discussed previously.




  
S^3VM Methods.
As mentioned above, traditional S^3VM 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 joachims1999transductive proposed a S^3VM^light 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 S^3VM in <cit.>.

The basic principle of CCCP is to linearize the concave part of S^3VM'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. <cit.> proposed an incremental

learning method for S^3VM which is suitable for the online scenario.
For gradient-based methods, 



Chapelle and Zien chapelle2005semi approximate the kernel matrix K using low-rank factors, then using gradient descent to solve S^3VM on the low-rank matrix.
BGS^3VM <cit.> uses budgeted SGD to limit the model size to two predefined budgets B_l and B_u.




§ PRELIMINARIES

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




 §.§ S^3VM Optimization Formulation

Given the training dataset X constituted with n^l labeled examples ℒ:={(x_i,y_i)}_i=1^n^l and n^u unlabeled examples 𝒰 := {x_i}_i=n^l+1^n, where n = n^l + n^u, x_i∈ℝ^d, and y_i ∈{1,-1}.

Traditional S^3VM solves the following problem.

    min_f∈ H     1/2 ||f||^2_ H+C/n^l∑_(x,y)∈ℒl( f(x),y)
    +C^*/n^u∑_x∈𝒰u(f(x))

where C and C^* are regularization parameters, ||·||_ H denotes the norm in RKHS, l(r,v) = max(0, 1 - vr) is the hinge loss, its subgradient l'(r,v)=0, if rv≥1, else l'(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 S^3VM losses and its subgradient u'(r) in Table <ref>.





For S^3VM 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 S^3VM formulation as follows.

    min_f∈ H R(f)
    
       =   1/2 ||f||^2_ H+C/n^l∑_(x,y)∈ℒl( f(x),y)
    +C^* 𝔼_x ∼ P(x) u(f(x))

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.





 §.§ 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 <cit.>,
for any positive definite PD kernel k(·,·), there exists a set Ω, a probability measure ℙ and a random feature map ϕ_ω(x), such that











k(x,x')=∫_Ωϕ_ω(x) ϕ_ω(x')dℙ(ω).

In this way, the value of the kernel function can be approximated by explicitly computing random features ϕ_ω(x)=[1/√(m)ϕ_ω_1(x),1/√(m)ϕ_ω_2(x),⋯,1/√(m)ϕ_ω_m(x)], i.e.,


    k(x,x')≈1/m∑_i=1^mϕ_ω_i(x) ϕ_ω_i(x')

where m is the number of random features.
Using Gaussian RBF kernel

as a concrete example, it yields a Gaussian distribution ℙ(ω) over random feature maps of Fourier basis functions ϕ_ω_i(x) = √(2)cos(ω_i^Tx+b) to compute its feature mapping, where ω_i is drawn from ℙ(ω) and b is drawn uniformly form [0,2π].
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') has a corresponding RKHS ℋ. An RKHS ℋ

has the reproducing property, i.e.,
∀ x∈𝒳, ∀ f∈ℋ, we always have ⟨ f(·),k(x,·)⟩_ℋ=f(x).
Besides, functional gradient in RKHS ℋ can be computed as ∇ f(x)= k(x, ·) and ∇ ||f||^2_ℋ = 2f.




















§ TRIPLY STOCHASTIC S^3VM


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 S^3VM problem.


 §.§ Triply Stochastic Gradient

From Eq. (<ref>), it is not hard to notice that R(f) involves two different data sources. Taking into consideration the distribution of random features ω∼ℙ(ω) 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,

    g(·) = f(·) + ξ(·)

where ξ(·) is the gradient contributed by the loss from both labeled and unlabeled data. It can be computed using the chain rule

    ξ(·) =Cl'(f(x^l),y^l)k(x^l, ·)+C^*u'(f(x^u))k(x^u, ·)

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. (<ref>), when we use stochastically generated random feature ω, we can further approximate ξ(·) as:

    ξ(·) ≈ζ(·)
    
    
    =    Cl'(f(x^l),y^l)ϕ_ω(x^l)ϕ_ω(·)
    +C^*u'(f(x^u))ϕ_ω(x^u)ϕ_ω(·)

note that ξ(·) = 𝔼_ω[ζ(·)]. This leads to an unbiased estimator of the original functional gradient with three layers of stochasticity, i.e.,

    ∇ R(f) = 𝔼_(x^l,y^l)∈ℒ𝔼_x^u∼ P(x)𝔼_ω(ζ(·)) + f(·)

Since three random events occur per iteration, i.e. x^l, x^u, ω, 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:

    f_t+1(·) = f_t(·) - γ_t (ζ_t(·)+f_t(·))  =∑_i=1^ta^i_t ζ_i(·)

where γ denotes the step size and  the initial value f_1(·)=0. It is straight forward to calculate that a_t^i=-γ_i∏_k=i+1^t(1-γ_k).

Ideally, if we could somehow compute the stochastic (functional) gradients ξ_j(·), the update rule becomes:

    h_t+1(·) = h_t(·) - γ_t (ξ_t(·) + h_t(·)) = ∑_i=1^ta^i_t ξ_i(·)

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(·)=0. However, to avoid the expense of kernel computation, our algorithm will use the triply stochastic update rule Eq. (<ref>) instead of Eq. (<ref>).




 §.§ Algorithm

Based on the above triply stochastic gradient update rules (<ref>), we provide the TSGS^3VM training and prediction procedures  in Algorithms <ref> and <ref> receptively.
Notice that directly computing all the random features still needs
a large amount of memory.
Following the pseudo-random number generators setting of <cit.>, our random feature generator is initialized by a predefined seed according to iteration. Thus, TSGS^3VM 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 <ref>): Stochastically sample a labeled sample (x^l_i,y^l_i) and an unlabeled sample x^u_i from different distribution respectively.
	
  * Sample random features (line 4 in Algorithm <ref>): Stochastically sample ω^i ∼ℙ(ω) with seed i and generate random features.
	
  * Update coefficients (lines 5-8 in Algorithm <ref>): Evaluate function value and update f according to Eq. (<ref>).



	For each iteration, TSGS^3VM 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 TSGS^3VM is O(mT^2). Due to the use of random features and pseudo-random method, TSGS^3VM only requires O(T) memory, where T is the iteration number.









§ THEORETICAL GUARANTEES


We follow the common goal of non-convex analysis <cit.> to bound 𝔼||∇ 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 (<ref>), h_t will always be inside of 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 H.
As a consequence, 𝔼||∇ R(f)||^2_ H=0 is not the stationary point of the objective function (<ref>). From Eq. (<ref>) and Eq. (<ref>), 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. <ref>, for a general non-convex optimization problem R(h),  we prove that the h_t+1  converges to a stationary point f_* (i.e., 𝔼||∇ R(h_t+1)||^2_ H<ϵ_1) firstly. Then we prove that f_t+1(x)  keeps close to its hypothetic twin h_t+1(x) for any x ∈ X (i.e., |f_t+1(x)-h_t+1(x)|^2<ϵ_2).






Our analysis is built upon the following assumptions which are standard for the analysis of non-convex optimization and DSG <cit.>.

	(Lipschitzian gradient) The gradient function ∇ R(f)  is Lipschitzian, that is to say
	
    ||∇ R(f) -∇ R(g)||_ H≤ L||f-g||_ H, ∀ f,g ∈ H



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


	(Bound of derivative) The derivatives are bounded: |l'|<M^l and |u'|<M^u, where l' and u' 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.



	(Bound of kernel and random features) We have an upper bound for the kernel value, k(x,x') ≤κ. There is an upper bound of random feature norm, i.e., |ϕ_ω(x)ϕ_ω(x')| ≤ϕ.

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

	
	For any x ∈ X, fix γ = θ/T^3/4 with 0<θ≤ T^3/4, we have
	
    𝔼_x^l,x^u, ω_t[|f_t(x) - h_t(x)|^2 ] ≤DT^1/2

	
	where D = θ^2M^2(√(κ)+√(ϕ))^2.


	The error between f_t+1 and h_t+1 is mainly induced by random features.
	Theorem <ref> shows that this error has the convergence rate of O(1/√(T)) with proper step size.
	



	
	For fixed γ=θ/T^3/4, 0<θ≤ T^3/4, we have that
	
    𝔼_x^l,x^u, ω_t[||∇ R(h_t)||^2_ H]≤E/T^1/4+F/T^3/4

	where E=1/θ[R(h_1)-R^*]+θ M^2M'(√(κ)+√(ϕ))κ, F=2θ M^2Lκ,  R^* denotes the optimal value of (<ref>).


	Instead of using the convexity assumption  in <cit.>, Theorem <ref> 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  𝔼_x^l,x^u, ω_t[||∇ R(h_t)||^2_ H] as shown in  Appendix. Note that compared to the strong assumption (i.e., the good initialization)  used in <cit.>, the assumptions used in our proofs are  weaker and more realistic.









§ EXPERIMENTS AND ANALYSIS

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



 §.§ Experimental Setup



To show the advantage our TSGS^3VM for large-scale S^3VM learning, we conduct the experiments on large scale datasets to compare TSGS^3VM 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 follows[BLS^3VM and S^3VM^light can be found in http://pages.cs.wisc.edu/ jerryzhu/ssl/software.html].

	
	
  * BLS^3VM <cit.>: The state-of-art S^3VM algorithm based on CCCP  and SMO algorithm <cit.>.	
	
  * S^3VM^light <cit.>: The implementation in the popular S^3VM^light software. It is based on the local combinatorial search guided by a label switching procedure.
	
  * BGS^3VM<cit.>: Our implementation of BGS^3VM in MATLAB.
	
  * FRS^3VM: Standard SGD with fixed random features.
	
  * TSGS^3VM: Our proposed S^3VM algorithm via triply stochastic gradients.













  
Implementation.
We implemented the TSGS^3VM algorithm in MATLAB. For the sake of efficiency, our TSGS^3VM 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')=exp(-σ||x-x'||^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 σ), the parameters C^* was set to Cn^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×7 coarse grid linearly spaced in the region {log_10 C , log_10σ)|  -3 ≤log_10 C ≤ 3, -3 ≤log_10σ≤ 3} for all methods.
For TSGS^3VM, the step size γ equals 1/η, where 0 ≤log_10η≤ 3 is searched after C and σ. Besides, the number of random features is set to be ⌈√(n)⌉ 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 TSGS^3VM, we set the minimum budget sizes B_l and B_u as 100 and 0.2*n_u respectively for BGS^3VM.

We stop TSGS^3VM and BGS^3VM after one pass over the entire dataset. We stop FRS^3VM after 10 pass over the entire dataset to achieve a comparable accuracy.

All results are  the average of 10 trials.




  
Datasets.
Table <ref> summarizes the 8 datasets used in our experiments. They are

from LIBSVM[https://www.csie.ntu.edu.tw/ cjlin/libsvmtools/datasets/] and

UCI[http://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.






































 §.§ Experimental Results

Fig. <ref> shows the test error v.s. the training size for different algorithms. 


The results clearly show that TSGS^3VM runs much faster than other methods. Specifically, Figs. <ref>d and <ref>h confirm the high efficiency of TSGS^3VM even on the datasets with one million samples. Besides, TSGS^3VM requires low memory benefiting  from pseudo-randomness for generating random features, while BLS^3VM and S^3VM^light would be often out of memory on  large scale datasets.

Fig. <ref> 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 TSGS^3VM achieves similar generalization performance as that of BLS^3VM, S^3VM^light, and BGS^3VM methods which confirm that TSGS^3VM converge well in practice. Besides, TSGS^3VM achieves better generalization performance than FRS^3VM, because TSGS^3VM 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 TSGS^3VM is much more efficient and scalable than these algorithms while retaining the similar generalization performance.




§ CONCLUSION

In this paper, we provide a novel triply stochastic gradients algorithm for kernel S^3VM to make it scalable.



We establish new theoretic analysis for TSGS^3VM which guarantees that TSGS^3VM can efficiently converge to a stationary point for a general non-convex learning problem under weak assumptions. As far as we know, TSGS^3VM 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 TSGS^3VM.







§ 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.



§ PROOF OF THEOREM <REF>










To proof theorem <ref>, we first give lemma <ref> as follows

	
	For any x ∈ X, consider a fix step size γ, and 0<γ≤1, we have that
	
    𝔼_x^l, x^u, ω_t[|f_t(x) - h_t(x)|^2 ] ≤ B^2_1,t+1

	
	where B^2_1,t+1 := M^2(√(κ)+√(ϕ))^2tγ^2, and B_1,1=0.

Proof. We denote W_i(x)=W_i(x;x_i^l,x_i^u,ω_i)=a_t^i(ζ^i(x)-ξ^i(x)). Based on the definition and assumptions in main body, W_i(x) is bounded as follows

    |W_i(x)|
    
       ≤   c_i=   |a_t^i|(|ζ_i(x)|+|ξ_i(x)|)
    
       =  |a_t^i|[|Cl'(f(x_i^l),y_i^l)k(x_i^l,x)+C^*u'(f(x_i^u))k(x_i^u,x)|
         +|Cl'(f(x_i^l),y_i^l)ϕ_ω_i(x_i^l)ϕ_ω_i(x) 
         +C^*u'(f(x_i^u))ϕ_ω_i(x_i^l)ϕ_ω_i(x)|]
    
       ≤   |a_t^i| [(CM^l+C^*M^u)(√(κ)+√(ϕ))]
    
       =   M(√(κ)+√(ϕ))|a_t^i|

Based on the definition of a_t^t, |a_t^t|≤γ, and for any i we have |a_t^i|≤γ∏_j=i+1^t(1-γ)≤γ due to 0< γ≤1. Consequently, ∑_i=1^t|a_t^i|^2≤ tγ^2. Then we have 𝔼_x^l_t,x^u_t, ω_t[|f_t(x) - h_t(x)|^2 ] ≤ M^2(√(κ)+√(ϕ))^2∑_i=1^t|a_t^i|^2≤ M^2(√(κ)+√(ϕ))^2tγ^2.
We obtain the Lemma <ref>. Taking γ = θ/T^3/4, we have 

    B^2_1,t+1   :=    M^2(√(κ)+√(ϕ))^2tθ^2/T^3/2
       ≤   M^2(√(κ)+√(ϕ))^2Tθ^2/T^3/2
       ≤   M^2(√(κ)+√(ϕ))^2θ^2/T^1/2

then we obtain theorem <ref>.



§ PROOF OF THEOREM <REF>









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

    g_t    =  ξ_t + h_t
       =   Cl'(f_t(x_t^l), y_t^l) k(x_t^l, ·) 
          + C^*u'(f_t(x_t^u)) k(x_t^u, ·) +  h_t 
    ĝ_t    =  ξ̂_t + h_t
       =   Cl'(h_t(x_t^l), y_t^l) k(x_t^l, ·) 
          + C^*u'(h_t(x_t^u)) k(x_t^u, ·) + h_t 
    ∇ R(h_t)    =  𝔼_x^l,x^u[ĝ_t]
    
       =  𝔼_x^l,x^u[Cl'(h_t(x_t^l), y_t^l) k(x_t^l, ·) 
          + C^*u'(h_t(x_t^u)) k(x_t^u, ·)] +  h_t

Besides, we use 𝔼 to denotes 𝔼_x^l_t,x^u_t,ω_t for simplicity sometimes.
Similar as <cit.>, using the assumption 1 and  h_t+1=h_t - γ g_t, ∀ t≥ 1, for t = 1,⋯, T we have


    R(h_t+1)
    
       ≤   R(h_t)+⟨∇ R(h_t), h_t+1-h_t⟩+L/2||h_t+1-h_t||^2_ H
        =   R(h_t)-γ⟨∇ R(h_t),  g_t⟩+Lγ^2/2||g_t||^2_ H
        =   R(h_t)-γ⟨∇ R(h_t),  g_t-ĝ_t+ĝ_t-∇ R(h_t)
    
         +∇ R(h_t)⟩
    +Lγ^2/2||g_t||^2_ H
        =   R(h_t)-γ||∇ R(h_t)||^2_ H+γ⟨∇ R(h_t),  ĝ_t-g_t⟩
         +γ⟨∇ R(h_t),∇ R(h_t)-ĝ_t⟩+Lγ^2/2||g_t||^2_ H



















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

    1/T∑_t=1^Tγ||∇ R(h_t)||^2_ H
       ≤  1/T[ R(h_1)-R(h_T+1)+∑_t=1^Tγ⟨∇ R(h_t),  ĝ_t-g_t⟩
         + ∑_t=1^Tγ⟨∇ R(h_t),∇ R(h_t)-ĝ_t⟩+∑_t=1^TLγ^2/2||g_t||^2_ H]
    
       ≤  1/T[R(h_1)-R^*+∑_t=1^Tγ⟨∇ R(h_t),  ĝ_t-g_t⟩
         + ∑_t=1^Tγ⟨∇ R(h_t),∇ R(h_t)-ĝ_t⟩+∑_t=1^TLγ^2/2||g_t||^2_ H]

where R^* is the optimal value of R(h_t) and the last inequality follows from the fact that R(h_T+1)≥ R^*. 

Taking expectations on both sides we have

    𝔼[||∇ R(h_t)||^2_ H]
    
       ≤  1/Tγ[R(h_1)-R^*]+𝔼[⟨∇ R(h_t),  ĝ_t-g_t⟩]
    
         + 𝔼[⟨∇ R(h_t),∇ R(h_t)-ĝ_t⟩]+Lγ/2𝔼[||g_t||^2_ H]

Let us denote ℋ_t=√(||∇ R(h_t)||^2_ H), ℳ_t=||g_t||^2_ H,𝒩_t=⟨∇ R(h_t),∇ R(h_t)-ĝ_t⟩,ℛ_t=⟨∇ R(h_t),  ĝ_t-g_t⟩. 

From lemma <ref>, we have the bound as follows 

    𝔼[ℋ_t]^2   ≤ 4 κ M^2
    𝔼[𝒩_t]   =0
    ℳ_t   ≤ 4 κ M^2
    𝔼[ℛ_t]   ≤κ M M'B_1,t



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

    𝔼[||∇ R(h_t)||^2_ H]
    
       ≤  1/Tγ[R(h_1)-R^*]+ κ M M'B_1,t +2Lγκ M^2
       ≤  1/Tγ[R(h_1)-R^*]+ κ M^2M'√(t)γ (√(κ)+√(ϕ))
          +2Lγκ M^2

Let γ = θ/T^3/4, we have

    𝔼[||∇ R(h_t)||^2_ H]
    
       ≤  1/T^1/4[1/θ[R(h_1)-R^*]]
    + 1/T^1/4θκ  M^2M'(√(κ)+√(ϕ))
          +1/T^3/42θκ M^2L

Thus, we complete the proof.



§ LEMMA <REF>


	
	In this lemma, we prove the inequalities (<ref>)-(<ref>)

Proof Similar to <cit.>, given the definitions of ℳ_t,ℋ_t,𝒩_t,ℛ_t we have

(1) ℳ_t≤ 4 κ M^2; 

This is because ℳ_t=||g_t||^2_ H=||ξ_t+ h_t||_ H^2≤ (||ξ_t||_ H+||h_t||_ H)^2.
We have 

    ||ξ_t||_ H
       =  ||Cl'(f_t(x_t^l),y_t^l)k(x_t^l,·)+C^*u'(f_t(x_t^u))k(x_t^u,·)||_ H
       ≤  ||Cl'(f_t(x_t^l),y_t^l)k(x_t^l,·)||_ H+||C^*u'(f_t(x_t^u))k(x_t^u,·)||_ H
       ≤   CM^lκ^1/2+C^*M^uκ^1/2≤κ^1/2M

where the first inequality because triangle inequality, and from lemma <ref> we have ||h_t||_ H≤κ ^1/2M. Applying these bounds leads to ℳ_t ≤ 4 κ M^2

(2) 𝔼_x^l_t,x^u_t,ω_t[ℋ_t]^2≤ 4 κ M^2; 
This is because 

    𝔼_x^l_t,x^u_t,ω_t[ℋ_t]^2   =  ||𝔼_x^l_t,x^u_t,ω_t[ξ̂_t]+ν h_t||^2_ H
       ≤   (||𝔼_x^l_t,x^u_t,ω_t[ξ̂_t]||_ H+v||h_t||_ H)^2

where ||𝔼_x^l_t,x^u_t,ω_t[ξ̂_t]||_ H≤κ^1/2M according to (<ref>), and from lemma <ref> we have ||h_t||_ H≤κ ^1/2M. Applying these bounds leads to 𝔼_x^l_t,x^u_t,ω_t[ℋ_t]^2 ≤ 4 κ M^2

(3) 𝔼_x^l_t,x^u_t,ω_t[𝒩_t]=0; This is because

    𝔼_x^l_t,x^u_t,ω_t[𝒩_t]
    
       =  𝔼_x^l_t-1,x^u_t-1,ω_t
    [𝔼_x^l_t,x^u_t[⟨∇ R(h_t),∇ R(h_t)-ĝ_t⟩|x^l_t-1,x^u_t-1,ω_t]]
    
       =  𝔼_x^l_t-1,x^u_t-1,ω_t[⟨∇ R(h_t),𝔼_x^l_t,x^u_t[∇ R(h_t)-ĝ_t]⟩]=0











(4) 𝔼_x^l_t,x^u_t,ω_t[ℛ_t]= ≤κ M M'B_1,t; This is because

    𝔼_x^l_t,x^u_t,ω_t[ℛ_t]
    
       =  𝔼_x^l_t,x^u_t,ω_t[⟨∇ R(h_t),  g_t-ĝ_t⟩] 
       =  𝔼_x^l_t,x^u_t,ω_t[⟨∇ R(h_t),[Cl'(h_t(x_t^l),y_t^l)-Cl'(f_t(x_t^l),y_t^l)]
    
         · k(x_t^l,·)⟩]
    
         +𝔼_x^l_t,x^u_t,ω_t[⟨∇ R(h_t),[C^*u'(h_t(x_t^u))-C^*u'(f_t(x_t^u))]
    
         · k(x_t^u,·)⟩]
    
       ≤  𝔼_x^l_t,x^u_t,ω_t[|Cl'(h_t(x_t^l),y_t^l)-Cl'(f_t(x_t^l),y_t^l)|
    
         ·||k(x_t^l,·)||_ H·||∇ R(h_t)||] 
    
         + 𝔼_x^l_t,x^u_t,ω_t[|C^*u'(h_t(x_t^u))-C^*u'(f_t(x_t^u))|
    
         ·||k(x_t^u,·)||_ H·||∇ R(h_t)||]


    ≤   Cκ^1/2L'·𝔼_x^l_t,x^u_t,ω_t[|h_t(x_t^l)-f_t(x_t^l)|·||∇ R(h_t)||_ H] 
         + C^*κ^1/2U'·𝔼_x^l_t,x^u_t,ω_t[|h_t(x_t^u)-f_t(x_t^u)|·||∇ R(h_t)||_ H] 
       ≤   Cκ^1/2L'
    
         ·√(𝔼_x^l_t,x^u_t,ω_t|h_t(x_t^l)-f_t(x_t^l)|^2)·√(𝔼_x^l_t,x^u_t,ω_t||∇ R(h_t)||_ H^2)
         + C^*κ^1/2U'
    
         ·√(𝔼_x^l_t,x^u_t,ω_t|h_t(x_t^u)-f_t(x_t^u)|^2)·√(𝔼_x^l_t,x^u_t,ω_t||∇ R(h_t)||_ H^2)
       ≤   Cκ^1/2L'B_1,t√(𝔼_x^l_t,x^u_t,ω_t[ℋ_t]^2)
         +C^*κ^1/2U'B_1,t√(𝔼_x^l_t,x^u_t,ω_t[ℋ_t]^2)
       ≤  κ M (CL'+C^*U')B_1,t=κ M M'B_1,t

where the first and third inequalities are due to Cauchy-Schwarz Inequality, the second inequality is due to L'-Lipschitz continuity of l'(·,·) and U'-Lipschitz continuity of u'(·,·), the forth inequality is due to lemma <ref> and fifth inequality is due to the bound of 𝔼_x^l_t,x^u_t,ω_t[ℋ_t]^2 we give above.



§ LEMMA <REF>


	
	For any t = 1⋯ T, we have ||h_t||≤κ^1/2M

Proof For t=1, according to the definition of h_t we have h_1=0, ||h_1||_ H = 0 ≤κ^1/2M.
For any t=1⋯ T-1 if we have ||h_t||_ H≤κ^1/2M, then according to the definition of h_t we have

    ||h_t+1||_ H   =  ||(1- γ)h_t-γξ_t(·)||_ H
       ≤   (1- γ)||h_t||_ H+γ ||ξ_t(·)||_ H
       ≤   (1- γ)κ^1/2M+γκ^1/2M
       ≤  κ^1/2M

The first inequality is because triangle inequality, the second inequality is because the assumption bound of h_t and the bound of ξ_t(·) in (<ref>).
Now we have lemma <ref>.



§ CONVERGENCE CURVES RELATED TO ITERATIONS

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


named



