Modified online Newton step based on element wise multiplication

TL;DR

This paper introduces a modified online Newton step method that uses element-wise multiplication to efficiently handle large multi-class datasets, maintaining performance while reducing computational complexity.

Contribution

It proposes a novel online Newton step variant that stores smaller matrices using element-wise operations, enabling faster computation on large datasets.

Findings

Faster computation due to reduced matrix size

Mistake rate comparable to existing methods

Effective on large multi-class datasets

Abstract

The second order method as Newton Step is a suitable technique in Online Learning to guarantee regret bound. The large data is a challenge in Newton method to store second order matrices as hessian. In this paper, we have proposed an modified online Newton step that store first and second order matrices of dimension m (classes) by d (features). we have used element wise arithmetic operation to retain matrices size same. The modified second order matrix size results in faster computations. Also, the mistake rate is at par with respect to popular methods in literature. The experiments outcome indicate that proposed method could be helpful to handle large multi class datasets in common desktop machines using second order method as Newton step.

Tables

Table 1. Table 1: Symbol descriptions

Notations	Definitions
$𝐅$	Convex feasible set
$𝐗$	${𝐱}_{\mathrm{𝟏}};{𝐱}_{\mathrm{𝟐}};\dots .;{𝐱}_{𝐭}$
$f$
$l_t$	Convex loss function of $t^{th}$ interation
$\nabla \left(f\right)$	Gradient of the loss function
${\nabla }^2\left(f\right)$	Second order derivative of the loss function
${𝐘}_{𝐭}$	$y_1;y_2;\dots ..y_t$
$\left|\right|.\left|\right|$	Euclidean norm
$R_G\left(T\right)$	Regret bound
$m$	number of classes in data set
$d$	number of feature in each vector $x_t$
$A$	second-order derivative of $l_t$
$g$	first order derivative of $l_t$
$A^T$	Transpose of matrix $A$
$⨀$	$A{.}^{\ast }b$ element-wise multiplication
$k$	$\frac{{\nabla }_t}{{\nabla }_t^2}$

Table 2. Table 2: Summary of datasets in the experiment

Dataset	$n$=#instaces	$d$= #features	$m=$ #classes	type
satimage	3104	36	6	classification
mnist	60000	780	10	classification
acoustic	78823	50	3	classification
Protein	17766	357	3	classification

Table 3. Table 3: Results of satimage dataset

Data Set:	satimage (#instances=3104,#features=36,#classes=6)
Algorithm:	mistake	#updates	time (s)
CW	0.191 +/-0.004	907.2 +/-21.0	0.253 +/-0.020
AROW	0.172 +/-0.008	2106.6 +/-43.4	0.308 +/-0.019
SCW1	0.153 +/-0.004	795.2 +/-35.3	0.265 +/-0.023
SCW2	0.157 +/-0.003	1004.8 +/-35.7	0.268 +/-0.032
ONS	0.171 +/-0.003	1321.2 +/-19.8	0.171 +/-0.006

Table 4. Table 4: Results of MNIST dataset

Data Set:	mnist (#instances=60000,#features=780,#classes=10)
Algorithm:	mistake	#updates	time (s)
CW	0.133 +/-0.002	15310.4 +/-87.9	462.148 +/-2.911
AROW	0.446 +/-0.079	29992.8 +/-3590.6	671.282 +/-80.369
SCW1	0.188 +/-0.002	13809.0 +/-124.5	313.469 +/-3.043
SCW2	0.130 +/-0.002	15207.0 +/-56.1	344.911 +/-2.255
ONS	0.111 +/-0.001	21063.4 +/-124.9	5.902 +/-0.015

Table 5. Table 5: Results of acoustic dataset

Data Set:	acoustic (#instances=78823,#features=50, #classes=3)
Algorithm:	mistake	updates	time (s)
CW	0.413 +/-0.001	48342.6 +/-106.9	9.224 +/-0.255
AROW	0.321 +/-0.001	77391.6 +/-62.3	11.769 +/-0.338
SCW1	0.344 +/-0.009	35305.4 +/-2004.5	8.217 +/-0.392
SCW2	0.322 +/-0.001	69253.4 +/-120.4	11.250 +/-0.296
ONS	0.343 +/-0.007	31932.2 +/-114.6	4.213 +/-0.118

Table 6. Table 6: Results of Protein dataset

Data Set:	Protein ( #instances=17766, #features=357, #classes=3 )
Algorithm:	mistake	updates	time (s)
CW	0.432 +/-0.002	11742.4 +/-47.5	31.420 +/-3.337
AROW	0.342 +/-0.002	17012.4 +/-10.2	42.742 +/-0.214
SCW1	0.374 +/-0.003	9312.2 +/-42.6	24.088 +/-0.115
SCW2	0.348 +/-0.001	11848.4 +/-70.9	30.351 +/-0.219
ONS	0.406 +/-0.002	15525.0 +/-63.3	1.406 +/-0.006

Equations

$$R_t=\sum _{t=1}^T{l}_t(w_t)-\underset{w^{\ast }\in S}{\inf }\sum _{t=1}^T{l}_t(w^{\ast }),$$

$$w_{t+1}=w_t-{\eta }_t.d_t,$$

$$f(w_t+d_t)\approx q_{w_t}(d_t)\equiv f(w_t)+\nabla f(w_t{)}^T{d}_t+\frac{1}{2}{d}_t^T\text{H}{d}_t,$$

$$\underset{w\in {\mathbb{R}}^{d\times m}}{\min }f(w)=\log (1+exp(-y_t<x_t{w}^T>)+\lambda ||w|{|}_1,$$

$$b=\nabla f(w_t)=y_t⨀x_t(f(w_t)⨀(1-f(w_t))+\lambda w_t$$

$$A={\nabla }^{2}f(w_t)=x_t^{2}b+\lambda$$

$$w_{t+1}=w_t-{\eta }_t{A}^{-1}⨀b$$

$$L_A(T)=\sum _{t=1}^T{l}_t(w_t)$$

$$L_w(T)=\sum _{t=1}^T{l}_t(w)$$

$$R_A(T)=L_A(T)-\underset{w\in F}{\min }{L}_w(T)$$

$$\begin{array}[]{lll}\hskip 8.5359pt||F||=\underset{w,w^{*}\in F}{\mathrm{max}}\ d(w,w^{*})\\ ||k||=\underset{w\in F,t\in{1,2,...,T}}{\mathrm{sup}}||k_{t}(w)||,\end{array}$$

$$R_G(T)\le (||F|{|}^2+||k|{|}^2)\sqrt{T}$$

$$l_t(w)\ge (l_t(w_t))\cdot (w-w_t)+l_t(w_t)$$

$$\begin{array}[]{lll}l_{t}(w_{t})-l_{t}(w^{*})\leq l_{t}(w_{t})-(k_{t}\cdot(w^{*}-w_{t})+l_{t}(w_{t}))\\ \hskip 79.6678pt\leq k_{t}\cdot w_{t}-k_{t}\cdot w^{*}\end{array}$$

$$\begin{array}[]{l}w_{t+1}=w_{t}-\eta_{t}\frac{\nabla_{t}}{\nabla_{t}^{2}}=w_{t}-\eta_{t}k_{t}\hskip 56.9055pt\texttt{where }k_{t}=\frac{\nabla_{t}}{\nabla_{t}^{2}}\\ w_{t+1}-w^{*}=w_{t}-w^{*}-\eta_{t}k_{t}\\ (w_{t+1}-w^{*})^{2}=((w_{t}-w^{*})-\eta_{t}k_{t})^{2}\\ \hskip 68.28644pt=(w_{t}-w^{*})^{2}-2(w_{t}-w^{*})\eta_{t}k_{t}+\eta_{t}^{2}||k_{t}||^{2}\end{array}$$

$$(w_{t+1}-w^{\ast }{)}^2\le \frac{1}{2{\eta }_t}((w_t-w^{\ast }{)}^2-(w_t-w^{\ast }{)}^2))+\frac{{\eta }_t}{2}||k|{|}^2$$

$$\begin{array}[]{ll}R_{G}(T)=\sum_{t=1}^{T}(w_{t}-w^{*})\cdot k_{t}\\ \hskip 34.14322pt\leq\sum_{t=1}^{T}\frac{1}{2\eta_{t}}((w_{t}-w^{*})^{2}-(w_{t+1}-w^{*})^{2})+\frac{\eta_{t}}{2}||k||^{2}\\ \hskip 34.14322pt\leq\frac{1}{2\eta_{1}}(w_{1}-w^{*})^{2}-\frac{1}{2\eta_{T}}(w_{T+1}-w^{*})^{2}+\frac{1}{2}\sum_{t=2}^{T}(\frac{1}{\eta_{t}}-\frac{1}{\eta_{t-1}})(w_{t}-w^{*})^{2}+\frac{||k||^{2}}{2}\sum_{t=1}^{T}\eta_{t}\\ \hskip 34.14322pt\leq||F||^{2}(\frac{1}{2\eta_{1}}+\frac{1}{2}\sum_{t=2}^{T}(\frac{1}{\eta_{t}}-\frac{1}{\eta_{t-1}}))+\frac{||k||^{2}}{2}\sum_{t=1}^{T}\eta_{t}\\ \hskip 34.14322pt\leq||F||^{2}\frac{1}{2\eta_{T}}+\frac{||k||^{2}}{2}\sum_{t=1}^{T}\eta_{t}\end{array}$$

$$\begin{array}[]{l}\sum_{t=1}^{T}\eta_{t}=\sum_{t=1}^{T}\frac{1}{2\sqrt{\eta_{t}}}\\ \hskip 28.45274pt\leq 1+\frac{1}{2}\int_{t=1}^{T}2\sqrt{t}\\ \hskip 28.45274pt\leq 1+(\sqrt{T}-1)\\ \hskip 28.45274pt\leq\sqrt{T}\end{array}$$

$$R_G(T)\le (||F|{|}^2+||k|{|}^2)\sqrt{T}$$

$$w_{t+1}=w_t-{\eta }_t\cdot A_t^{-1}{b}_t^T$$

Full text

url]https://sites.google.com/view/anujsharma/

1 Introduction

Machine Learning (ML) plays decisive role in emerging Artificial Intelligence (AI) applications and its data analysis. ML is a core sub-field of AI; it results in self-learning platform to machines, without being explicitly programmed. These algorithms are enabled to learn, grow, change and develop themselves. Conventional machine learning (batch based) is different from online learning paradigm as they require whole data at the time of training and these techniques are suffering from expensive re-training cost when dealing with a new instance coming. In big data era, conventional learning algorithms are more restrictive when data is huge and complex for real-world applications [1]. Different from batch-based learning; Online Learning (OL) includes important learning algorithms which are developed to learn models incrementally from data in a sequential manner [6],[5]. OL algorithms overcome the limitation of batch-based learning as OL instantly update the model when new instance arrives. Most of the OL algorithms are inspired from online convex optimization. An online convex optimization consists of a convex set $S$, and a convex payoff function $l_{t}$. At step $t$, the online convex optimization choose a weight vector $w_{t}\in S$ then it computes a loss $l_{t}(w_{t})$, which is based on the convex payoff function $l_{t}(.)$ defined over a convex set $S$ [13]. The objective of the online learning algorithm to attain a minimum regret bound, where regret is described as:

[TABLE]

where $w^{*}$ is the minimum value of the payoff function as $\sum\limits_{t=1}^{T}l_{t}(w)$ over the convex set $S$.

Based upon the optimization techniques, OL algorithms categorized in the following way: (i) first-order OL where only first-order feature information is used [9],[19],[16],[8] (ii) second order OL where not only first-order but also second order feature information used in training [15],[12], [14],[4]. The first OL algorithm is Perceptron [17] based upon the first order derivation of the cost function, which updates the model by adding and subtracting the loss of the misclassified instance with a fixed weight. Recently, various methods were proposed based upon the first order OL by maximizing the margin value. One developed Relaxed Online Margin Algorithm (ROMMA) [11] is an incremental approach based upon the maximum margin. ROMMA used the first-order derivation of the linear function for classification. Another approach is Passive Aggressive (PA) [9] that classified the current instance based upon the loss function, when the loss is zero updation is passive otherwise updation is aggressive. By analyzing performance of the first-order based OL techniques, we observe that large margin method are out-performed the perceptron algorithm.

In recent year, second order methods gain popularity as they overcome the limitations of first-order method by exploiting the second order information. The well known second order method is Second-Order Perceptron (SOP) [15], which is the variant of whitened perceptron algorithm. In this work the author defined the interaction between eigenvalue of the correlation matrix of the data and the target vector. There are various other large margin second order online learning methods are proposed, such as Confidence-Weighted (CW) [14] learning defined over the notation of confidence parameter. The less confident parameters are updated more aggressively than confident one. The limitation of CW, its aggressive hard margin strategy in noisy data. To overcome this problem, researchers proposed the another variant of CW learning based upon the adaptive regularization of each training instance. In general, the performance and convergence rate of second-order OL is better than the first-order algorithms.

The Online Newton Step (ONS) [3] is analogue of the Newton-Raphson method [2]. It moves in the direction of the vector which inverse Hessian multiplied by the gradient. In ONS case, the direction is $H_{t}^{-1}\nabla_{t}$ and the matrix $A_{t}$ is Hessian. Second-order algorithms such as ONS lead to lower regret bound as compared to first-order methods. Our main contribution in the proposed work is implementation of second-order algorithm analogue to the Online Newton step. We have kept the dimension of first order and second order derivatives same as objective function using element wise multiplication and inclusion of unit vectors or multiplication with feature vector. Therefore, we are able to reduce the number of iterations required in the previous used ONS. The main idea behind the change in dimension of matrix is to reduce the calculation time of learning system. Our first order and second order matrices as $b$ and $A$, do not share same definition as gradient and hessian matrices. Therefore, we have assigned names as matrices $b$ and $A$, differently from gradient and hessian notations, as used in literature work. The highlights of the study are:

A suitable second order online learning method using Newton step.

• 2.

First and second order matrices are of order $m\times d$ instead of $d\times d$ as used in literature work.

• 3.

The promising online computation time cost as compared to previous work and of complexity $\mathrm{O}(md)$.

• 4.

Analysis of regret bound of proposed method.

The rest of the paper is organized as follows. The Section 2 presents the notations used in this paper and the role of variables in convex optimization problems. In section 3, we introduce the proposed Online Newton Step for multiclass with the new dimensions of the matrices. In section 4, we present the theoretical analysis and regret bound of the proposed method. In Section 5, summarized the experiments based on the proposed method with the benchmarks datasets. The section 6 concludes the paper with finding.

2 Preliminaries

In this section, we present the notations used in this paper, and formally define the problem of second order convex optimization.

2.1 Notations

In Table 1, we present the main symbols used in this paper. We have used bold upper case character for matrix (e.g $\mathbf{(A)}$) representation and $\mathbf{A^{-1}}$ and $\mathbf{A^{T}}$ denote the inverse and transpose of matrix respectively, small bold case character represent the vector ($\mathbf{x}$). $||x||$ used for Euclidean norm of a vector that is dual to itself. $\nabla$ denote the first order derivative and $\nabla^{2}$ denote the second order derivatives of the objective function.

In our case, the dimension of the second order derivative is $m\times d$, where $m$ is the number of classes in respective data set and $d$ is the number of features in current vector $\mathbf{x_{t}}$.

2.2 Second order online convex optimization

Many online learning algorithms formulated as an online convex optimization task. The main aim of second order methods is to exploits the second order information to speed up the convergence of the optimization. The popular second order online algorithm is online Newton step. Like ONS, second order methods update the model in sequence of consecutive rounds. At each round $t$, the online learner pick a data vector $x_{t}$ from a convex set $F$ such that $x_{t}\in X$. After the prediction is calculated on vector $x_{t}$, a convex loss function $l_{t}$ is revealed, then the online learner suffer from an instantaneous loss $l_{t}(x)$. In second order online convex optimization, we assume that the sequence of loss function $l_{1},l_{2},....,l_{T}:X\rightarrow\mathbb{R}$ are fixed in advance. The main goal of online learner is to minimize the regret. In second order learning, the learner has access to the gradient as well as second order derivative of the loss function at any point in the convex set $F$.

3 Modified Online Newton Step using element wise multiplication

In online learning, Newton method is second order optimization algorithm, which iteratively updates the weight vector $w\in\mathrm{R}^{d\times m}$ in a sequential manner of an objective function $f$ by computing direction $d_{t}$ and update weight vector:

[TABLE]

where $\eta_{t}$ is a step size and $d_{t}$ is search direction. The benefit of using Newton method is that $f$ can be locally approximated around each $w_{t}$, upto second order, by the quadratic:

[TABLE]

where $\textbf{H}=H(w_{t})$ is the Hessian matrix of $f$ at $w_{t}$. To move in a good direction to, reduce to minimize this quadratic ($q(w_{t})$) with respect to $d_{t}$, to find a descent direction, we use a Newton algorithm. Computing and storing the full Hessian matrix ($H$) takes $\mathrm{O}(d^{2})$ memory, which is infeasible for high-dimensional functions such as the loss functions of neural nets with large numbers of features.

The proposed work in this paper is an attempt to overcome the challenges of Hessian complexity as $\mathrm{O}(d^{2})$. The goal of the present work is to facilitate research an online learning optimization for large-scale data. We address a logistic minimization problem defined as:

[TABLE]

where $w\in\mathbb{R}^{d\times m}$ represent the model parameter and $T$ define the number of instances $(x_{t},y_{t})$. $L(<w_{t},x_{t}>,y_{t})$ is the loss function.

The proposed algorithm is a online variant of the well know Newton method [12] for finding the roots. In online learning, [5] at time $t$, the learner pick one instance $x_{t}$ from the environment and then make a prediction of it’s class label $\hat{y}=sign(f(x_{t}))$, where $f$ is a prediction function that maps the feature vector to a real valued classification score. After the prediction, the true class label is revealed from the environment and update the classifier, when the learner makes a mistake ($\hat{y_{t}}\neq y_{t}$ ).

In this paper, we propose a new modified Newton step in online environment, which keeps the dimension of second order matrix as well as first order matrix same. The previous work on second order methods store the full information of second order derivative of the objective function, which results in more time to train the data when data is large. The new algorithm store the matrices $A$ and $b$, the dimension of $A$ and $b$ are $m\times d$, where $m$ is the number of classes and $d$ is the number of features in each instance.

The proposed algorithm ONS consist of two parts. 1) the size reduction of the second order matrix with respect to dimension. 2) The present rule of updating the classifier $w$. we discuss each part in detail follows.

In the algorithm 1, at $t^{th}$ round, the true label of $y_{t}$ of $x_{t}$ is revealed, we will update the classifier to make sure that it suffer a small loss on the $t^{th}$ instance and the new classifier $w_{t}$ is not far away from the previous classifier. Formally, we want to update the classifier by minimizing the objective function that is defined in equation 4. $l_{t}=max(0,1-y_{t}w_{t}^{T}x_{t})$ is the hinge loss function used.

When $l_{t}>0$, we solve the minimization problem 4 in the following steps:

Compute the $\nabla f(w_{t})$ and $\nabla^{2}f(w_{t})$ of equation 4

[TABLE]

[TABLE]

• 2.

Update the classifier parameter

[TABLE]

In the first step, we compute the matrix $b\in\mathrm{R}^{d\times m}$, which is equivalent to first order derivative of the logistic loss function $L_{t}$ with regularization parameter $L1$ regularization. In order to meet matrices multiplication criteria, we have multiplication with unit vector to fullfill the element wise multiplication criteria. This further help in strengthening our technique and results in low mistake rate. In the second step, We update the classifier and the updated equation is based upon Newton method for finding the root. Here we update weight matrix $w\in\mathrm{R}^{d\times m}$ and perform element wise $\bigodot$ multiplication. using element wise multiplication, we maintain the first order as well as second order derivative matrices dimensions as $m\times d$. The source code in Matlab for algorithm 1 given in Appendix 1.

The modify newton step algorithm is straight forward to implement, and running time is $\mathcal{O}(md)$ per iteration give the second order matrix. In this algorithm we use the step size $\eta_{t}=\frac{0.5}{\sqrt{t}}$.

3.1 Theoretical Analysis of modify Newton Step

As discussed by Zinkevich [19], we have follow the same definition 1. Our proof is different from Zinkevich, as we have used $\frac{\nabla_{t}}{\nabla_{t}^{2}}$ instead of $\nabla_{t}$ only.

Definition 1**.**

*A feasible set $F\in\mathrm{R}^{n}$ and a loss sequence $\{l_{1},l_{2},...\}$ where $l_{t}:F\rightarrow\mathrm{R}$ is a convex function in online convex optimization problem.

A vector $x_{t}\in F$, at step $t$, it receives the loss function $l_{t}$.*

Definition 2**.**

In an algorithm $A$, a convex problem for $F$ and $\{l_{1},l_{2},...\}$, if $\{w_{1},w_{2},...\}$ are selected vector by $A$, until time $T$, the loss of $A$ is:

[TABLE]

static feasible solution loss for $w\in F$ is

[TABLE]

Algorithm $A$ regret is

[TABLE]

We are specifying some parameters in order to state results in respect of regret of algorithm bounded.

[TABLE]

where $d(w,w^{*})=||w-w^{*}||$, here is the first results derived in this paper.

Theorem 1**.**

if $\eta_{t}=0.5/\sqrt{t}$, the regret of the modified Newton step is:

[TABLE]

Therefore, lim $sup_{T\rightarrow\infty}R_{G}(T)/T\leq 0$

Proof.

For all $t$, there exist a $k_{t}\in\mathrm{R}^{n}$ such that $l_{t}(w)=k_{t}\cdot w$ for all $w$. we compute $w_{1},w_{2},...$ by running the algorithm and begin with arbitrary $l_{1},l_{2},...$ We define $k_{t}=\nabla l_{t}(w_{t})$. For all $w$, $l_{t}(w)=k_{t}\cdot w$ to change $l_{t}$, the algorithm behavior is same as:

[TABLE]

Therefore, for all $w^{*}\in F:l_{t}(w^{*})\geq k_{t}\cdot(w^{*}-w_{t})+l_{t}(w_{t})$. Thus:

[TABLE]

This regret is least with respect to modified sequence of functions. Now, for $w^{*}$ on round $t$,we find regret bound as,

[TABLE]

Also, $||k_{t}||\leq||k||$

[TABLE]

Now, by summing we get,

[TABLE]

Now, if we define $\eta_{t}=\frac{1}{2\sqrt{t}}$,

[TABLE]

After putting the value of $\sum_{t=1}^{T}\eta_{t}$, we get regret bound as,

[TABLE]

∎

4 Experiments

Experiments of the proposed method were performed on multi-class classification datasets, i.e satimage, mnist, acoustic and protein. All the datesets are downloaded from LIBSVM website. We selected the four mutli-class classification datasets and table 2 shows the statistics of the datasets used in experimentations. All experiments are performed in MATLAB environment on a single computer with 3.4 GHz Intel core i7 processor and 8 GB RAM running under window 10 operating system.

We have compared our proposed modified ONS algorithm against the two following baselines:

The modified ONS change the dimension of second order as well as first order matrices which is $A$ and $b$ from $d\times d$ to $m\times d$.

• 2.

In modified ONS, We use the element wise multiplication denote by $\bigodot$ in Table 1 for reduction of matrices multiplication complexity.

To make a fair comparison, our modified ONS adopts the same experimental setting. We select randomly each feature vector $x_{t}$ at a time $t$, the regularization parameter $\lambda=0.001$ and the learning rate $\eta_{t}=\frac{1}{2\sqrt{t}}$. After that, all experimental results are reported by averaging the 20 runs with the help of Libol [18]. We add our proposed algorithm in Libol library and compare all the state-of-art second order algorithms.

We compare the proposed second order modified Newton step algorithm with the existing second order online learning algorithms [14], [10], [7]. In addition ONS is the baseline technique with full information feedback. To accelerate the computational efficiency, the modify newton step employ a pure newton formula.

[TABLE]

To compute $A_{t}^{-1}$ in time $\mathcal{O}(md)$ where $m$ is the number of classes in multiclass dataset and $d$ is feature vector in each record $t$, using the matrix-vector and vector-vector product after the $A_{t}^{-1}$ and $g_{t}^{T}$.

We have compared our algorithm against state-of-art algorithms using libol library [18]. We evaluate different second order online learning methods in the term of classification task. we select the Hinge loss $l(w_{t})=max(0,1-y_{t}w_{t}^{T}x_{t})$ as a classifier. In this experiment, the step size of ONS $\eta_{t}=\frac{1}{2\sqrt{t}}$. The results are shown in Figure 3. We find that the modify Newton step is much more efficient in term of running time and memory consumption.

In addition, the proposed second order online learning algorithm ONS converges faster than the other second order online learning methods used in experimentation. Hence, present approach provide a principled way to deal with large-scale online learning problems. Experimental results are presented using tables comparing the mistake rate, number of updates and time.

The Table 2 is shows the summarized detail of datasets.

The Table 3 shows the empirical results of the satimage dataset, which contain 3104 instances, each instance contain 34 features and 6 classes. In table 3, columns contains the algorithm name, mistake rate, number of updates, and time in seconds for respective algorithm. Our approach performed better in time cost as compared other methods. For mistake rate, we are close to SCW and SCW2 and outperformed the CW and ARROW algorithm.

The Table 4 present the experimentation results of the MNIST dataset, which contain 60000 instances and each instance contain 780 features with 10 classes. The MNIST dataset results, we are 40 times faster than other algorithms using the proposed algorithm. Our approaches also outperformed in the mistake rate which is less than in all second order online learning algorithm.

The Table 5 shows the empirical results of the acoustic dataset, which contain the 78823 instances, 50 feature of each instance and 3 classes. our approach also outperformed in time as shown in the table 5 and we find that our approach results in minimum updates.

The table 6 shows the results of the Protein dataset, which contains the 17766 instances, each instance contain 357 features and 3 classes. we also outperformed in the terms of time comparison and close to mistake rate achieved by other algorithms.

The figures [1],[2],[3],[4] shows the comparison of CW, AROW, SCW and SCW2 algorithms. Our proposed modified ONS shown in solid black line in figures [1],[2],[3],[4]. All figure include three parts, first part of figure shows the cumulative mistake rate, second part of fighure shows the number of updates and third part of figure shows the times in second.

The figure 1 shows the comparison between second order online learning algorithms discuss in literature with the multiclass classification dataset satimage. We outperformed in terms of time taken in comparison to other methods and better than CW and AROW for the mistake rate.

The figure 2 shows the results of MNIST dataset, our results are better in mistake rate and time comparison. The mistake rate is also less and time is 45 times less then other algorithms used in experimentation.

The figure 3 shows the results of acoustic data, in which, we performed better in time.

The figure 4 shown the result of Protein dataset, in which, we are 30 times faster than other algorithms.

5 Conclusion

The proposed method is an effort for second order online learning technique in order to address the challenging second order matrix size in large-scale dataset. We tackle the problem of second order matrix size by reducing the size of second order and first order matrices as $m\times d$, using element wise multiplication to retain the matrix size. We theoretically analyzed the regret bound of the proposed method and conducted a set of experiments to examine it’s empirical evaluation in training time and accuracy. We also applied large-scale classification datasets and results shows that our proposed algorithm do not need special hardware and could perform in common desktop machines. Our approach results in promising online computation time cost as discussed in experiment section. This further strengthen our approach as suitable second order learning to use in real time applications.