A Novel Neuron in Kernel Domain

Abstract

Kernel-based neural network (KNN) is proposed as a neuron that is applicable in online learning with adaptive parameters. This neuron with adaptive kernel parameter can classify data accurately instead of using a multilayer error backpropagation neural network. The proposed method, whose heart is kernel least-mean-square, can reduce memory requirement with sparsification technique, and the kernel can adaptively spread. Our experiments will reveal that this method is much faster and more accurate than previous online learning algorithms.

1. Introduction

Adaptive filter is the heart of most neural networks [1]. LMS method and its kernel-based methods are potential online methods with iterative learning that are used for reducing mean squared error toward optimum Wiener weights. Due to simple implementation of LMS [1], this method became one of the candidates for online kernel-based learning. The kernel-based learning [2] utilizes Mercer kernels in order to produce nonlinear versions of conventional linear methods.

After the introduction of the kernel, kernel least-mean-square (KLMS) [3, 4] was proposed. KLMS algorithm tries to solve LMS problems in reproducing kernel hilbert spaces (RKHS) [3] using a stochastic gradient methodology. KNN has such characteristics as kernel abilities and LMS features, easy learning over variants of patterns, and traditional neurons capabilities. The experimental results show that this classifier has better performance than the other online kernel methods, with suitable parameters.

Two main drawbacks of kernel-based methods are selecting proper value for kernel parameters and series expansions whose size equals the number of training data, which make them unsuitable for online applications.

This paper concentrates only on Gaussian kernel (for similar reasons to those discussed in [5]), while KNN uses other kernels too. In [6], the role of kernel width in the smoothness of the performance surfaces. Determining the kernel width of Gaussian kernel in kernel-based methods is very important. Controlling kernel width can help us to control the learning rate and the tradeoff between overfitting and underfitting.

Use of cross-validation is one of the simplest methods to tune this parameter which is costly and cannot be used for datasets with too many classes. So, the parameters are chosen using a subset of data with a low number of classes in [7]. In some methods, genetic algorithm [8] or grid search [5] is used to determine the proper value of such parameters. However, in all the mentioned methods, the kernel width is chosen as a preprocess which is against the principle of online learning methods. In addition, it has time overhead problem. Therefore, we follow methodologies that are consistent with online applications. In other works, the kernel width is scaled in a distribution-dependent way for SVM methods [9], kernel Polarization is used as a kernel optimality criterion independent of the learning machine [10], and in [11] a data-dependent kernel optimization algorithm is employed whcih maximizes the class separability in the empirical feature space. The computational complexity of these methods is quadratic with respect to the number of selected training data. Lately, an adaptive kernel width method to optimize minimum error entropy (MEE) criterion that has a linear complexity with respect to the length of the window used for computing the density estimate is proposed [12].

We proposed an adaptive kernel width learning in KNN method to maintain the online nature of it without any preprocess and reach convergence. We use the gradient property of KNN in order to estimate the best kernel width value during the process. Therefore, KNN method with adaptive Kernel width remains online and improves its accuracy as compared to the versions with fixed kernel width.

In other sides, it is needed to decrease computational complexity of kernel-based method to be useful in online application. Usually, used pruning [13–15] or fixed size models [13, 14, 16–18] in batching methods and truncation [17, 18] in online methods. We focus on online model reduction. KRLS and KLMS algorithms proposed some sparsification techniques based on ALD criterion [19, 20], by checking the linear dependency of the input feature vectors, which have a quadratic complexity. A sliding-window kernel RLS algorithm consists in only taking the last L pairs of arrived data, but it is a local method [21]. In [22, 23], proposed an online coherence based sparsification method on kernel-based affine projection (KAP) and KLMS that has only linear complexity. Coherence parameter is a fundamental quantity that characterizes the behavior of dictionaries in sparse approximation problems. In this paper, we combine the coherence criterion with proposed AKNN to control growth number of instances.

This paper is organized as follows. In Section 2, KLMS and KNN are introduced. Section 3 discusses adapting kernel parameter and sparsing instances in KNN. In Section 4, experiments illustrate the effectiveness of our approach compared to other existing methods. Finally, Section 5 summarizes the conclusions and points out avenues for further research.

2. Background

In this section, a short review of LMS and KLMS algorithms is presented. We introduce notations in Table 1 for better understanding of the formulation.

Table 1 

Notations.

2.1. LMS Algorithm

The main purpose of the LMS algorithm is to find a proper weight vector, which can reduce the MSE of the system output based on a set of examples (𝑥_𝑖,𝑑_𝑖). Therefore, LMS cost function is 𝐽=min_𝐰^𝑡_𝑖=1𝐝_𝑖−𝐱^𝑇_𝑖𝐰²=min_𝐰‖𝐝−𝐗𝐰‖². (1) The LMS algorithm approximates weight vector 𝐰 using gradient method [1]: 𝐰(𝑡+1)=𝐰(𝑡)−𝜂∇_𝐰𝐞²_𝑡=𝐰(𝑡)+𝜂𝐞_𝑡𝐱_𝑡, (2) where 𝜂 is the stepsize parameter. LMS algorithm is a famous linear filter because it has easy implementation and low computation.

2.2. KLMS Algorithm

The LMS algorithm can learn linear patterns very well but it is poor in learning nonlinear patterns. To overcome this problem, Puskal derived LMS algorithm directly in the kernel feature space [3, 4]. Kernel methods map the input data into a high dimensional space (HDS) [24]. The mapping procedure (Φ) helps to compute nonlinear problems using linear algorithms. After that, Mercer’s theorem provides a kernel function to compute inner product of data from HDS directly in the input space that is called the kernel trick: 𝑘𝑥,𝑥^′=𝜑(𝑥),𝜑𝑥^′. (3) The basic idea of the KLMS algorithm is to perform the linear LMS algorithm on {(𝜑(𝐱₁),𝑑₁),…,(𝜑(𝐱_𝑛),𝑑_𝑛)} in the feature space. So, KLMS cost function is given by 𝐽=min_𝐰‖𝐝−Φ𝐰‖², (4) where Φ and 𝐰 are matrixes of input vectors and weight vectors in feature space (RKHS), respectively. For convenience assuming that 𝐰(0)=0, therefore 𝐰(𝑡)=𝐰(𝑡)+𝜂∇_𝐰𝐞²_𝑡=𝜂^𝑡−1_𝑖=0𝐞_𝑖𝜑𝐱_𝑖. (5) By exploiting the kernel trick, output is given by 𝐲_𝑡=𝜂^𝑡−1_𝑖=0𝐞_𝑖𝑘𝐱_𝑖,𝐱_𝑡=𝜂𝐞(𝑡−1)^𝑇𝐤, (6) where 𝐤=[𝑘(𝐱₁,𝐱_𝑡),…,𝑘(𝐱_𝑡−1,𝐱_𝑡)]^𝑇. Good prediction ability in nonlinear channels is an advantage of the KLMS algorithm, but the complexity of this method for each input is 𝑂(𝑛), and 𝑛 is the number of training data, which is a problem especially in online application.

3. Kernel-Based Neural Network

This section includes five parts for better presentation of the proposed kernel-based neural network. First, KLMS based neuron is explained; then kernel adaptation and stepsize of adaptation and termination condition are discussed, and final subsection includes the sparsification.

3.1. The KLMS Neural Network (KNN)

The KLMS neural network (KNN) performs the classification task by adding a nonlinear logistic function to KLMS structure; Figure 1 illustrates the structure of KNN.

Figure 1 

Structure of neural network KLMS.

Similar to the KLMS algorithm, we perform a gradient search in order to find the optimum weight. If 𝑦_𝑡=𝑓(𝜑(𝐱_𝑡)^𝑇𝐰) is 𝑡th output and 𝐰(0)=0, then 𝐰(𝑡)=𝜂^𝑡−1_𝑖=0𝐞_𝑖𝑓^′𝜑𝐱_𝑖^𝑇𝐰(𝑡−1)𝜑𝐱_𝑡. (7) By using kernel trick, 𝐲_𝑡 is given as follows: 𝐲_𝑡=𝑓𝜂^𝑡−1_𝑖=0𝜶_𝑖𝑘𝐱_𝑖,𝐱_𝑡=𝑓𝜂𝜶(𝑡−1)^𝑇𝐤, (8) where 𝜶_𝑡=𝐞_𝑡𝑓^′(𝜂𝜶(𝑡−1)^𝑇𝐤). Therefore, KNN can determine the classifier output by calculating coefficients 𝜶 in learning state and input vectors.

According, what was said, finding a proper kernel play an important role in kernel-based learning. The best kernel function for learning each dataset is different. One solution for improving kernel function is finding the best kernel parameters. We try to determine the best kernel width 𝜎 in KNN (assuming a Gaussian kernel). Whereas KNN is an online learning method, we need an iterative method to find appropriate 𝜎 instead of methods by high complexity or methods that find it by preprocessing on data. A good suggestion is to select a random value for 𝜎 at the beginning of the training step and update it until convergence is obtained.

3.2. Adaptation of Kernel Width

The goal of LMS family’s methods is to reduce mean square error, and this aim will be achieved by using gradient search. It can be proved that the KNN, such as KLMS algorithm, converges when there are infinite numbers of samples. If kernel space structure and cost function were derivable, then gradient methods can be used for finding kernel’s parameters. Due to the derivability of Gaussian kernel function and MSE cost function, gradient search method can be used for updating kernel weight to reach the least mean square error. If the proposed modified KNN cost function is defined as 𝐽_𝑡(𝜶,𝜎)=𝐞²_𝑡,𝐞_𝑡=𝐝_𝑡−𝑓𝜂𝜶^𝑇𝐤 (9) and the kernel formulation is 𝑘_𝜎()−‖‖𝑥,𝑧=exp𝑥−𝑧²𝜎², (10) then there is an error function which depends on weight Ω and kernel weight 𝜎. Using gradient of 𝐞²_𝑡 with respect to σ, the least mean square error is achieved: 𝜎(𝑡+1)=𝜎(𝑡)−𝛾^′∇_𝜎(𝑡)𝐞²_𝑡, (11) where 𝛾^′ is stepsize and ∇_𝜎𝐞²_𝑡=2𝐞_𝑡𝜕𝐲_𝑡𝜕𝜎(𝑡)=2𝑒_𝑡𝜕𝑓𝜕𝑢𝜕𝑢(𝑡),𝜕𝜎where𝑢=𝜂^𝑡−1_𝑖=0𝜶_𝑖𝑘𝐱_𝑖,𝐱_𝑡𝜎. (12) At first, 𝜕𝑘/𝜕𝜎 can be solved that depends on 𝜎: 𝜕𝑘‖‖𝜕𝜎=2𝑥−𝑧²𝜎³−‖‖exp𝑥−𝑧²𝜎²⟹𝜕𝑢𝜕𝜎(𝑡)=𝜂^𝑡−1_𝑖=0𝜶_𝑖𝐱_𝑖−𝐱_𝑡²𝜎(𝑡)³𝑘𝐱_𝑖,𝐱_𝑡. (13)(14) By substituting (14) in (12), error gradient is given by: ∇_𝜎𝐞²_𝑡=−𝜂𝐞_𝑡𝑓^′(𝑢)^𝑡−1_𝑖=0𝐱_𝑖−𝐱_𝑡²𝜎(𝑡)³𝜶_𝑖𝑘𝐱_𝑖,𝐱_𝑡. (15) As a result, by substituting error gradient in (11) and using 𝜶_𝑡=𝐞_𝑡𝑓^′(𝑢), 𝜎 is updated by 𝜎(𝑡+1)=𝜎(𝑡)−𝛾𝜶_𝑡^𝑡−1_𝑖=0𝐱_𝑖−𝐱_𝑡²𝜎(𝑡)³𝜶_𝑖𝑘𝐱_𝑖,𝐱_𝑡, (16) where 𝛾=𝛾^′𝜂 is the stepsize that controls the convergence and speed of the kernel weight process. Choosing proper value for 𝛾 is a main challenge that some of its problems are explained in Section 3.2. The AKNN output can be calculated with coefficients 𝜶, kernel width 𝜎, achieved from training state, and input vectors 𝑋 as follows: 𝐲_𝑛=𝑓𝜂^𝑛−1_𝑖=0𝜶_𝑖𝑘_𝜎𝐱_𝑖,𝐱_𝑛, (17) where 𝑓(⋅) is a sigmoid function that covers all ranges of data (−∞<𝑢<+∞) and is bounded between 0 and 1. This function is derivable, which is important for using gradient method, and its derivative can be achieved from sigmoid function, but you can use other suitable functions. Sigmoid function and its derivatives are equal to 𝑓(𝑢)=11+𝑒^𝛽𝑢,𝑓^′(𝑢)=−𝛽𝑒^𝛽𝑢1+𝑒^𝛽𝑢=𝛽𝑓(𝑢)1−𝑓(𝑢). (18) According to (18), we can reformulate 𝜶_𝑡 for the next sample as below that decrease training time: 𝜶_𝑡=𝐞_𝑡𝑓^′(𝑢)=𝛽𝐞_𝑡𝐲_𝑡1−𝐲_𝑡. (19) Algorithm 1 describes the proposed adaptive KNN method that has a unique solution the same as KLMS algorithm.

Initialization: learning step 𝜂 learning kernel width step 𝛾 primal kernel width 𝜎 sparsity threshold μ 𝑡=1; While  {𝐱(𝑡),𝐝(𝑡)} available do  for  𝑙 instances do   % compute distances of dictionary instances to tth instance   𝐝𝐢𝐬𝑖=𝑥𝑖−𝑥𝑡2;                   𝑂(𝑚𝑡−1)   % compute kernel vector, output and error for tth instance   𝐤=exp(−𝐝𝐢𝐬𝑇/𝜎2),𝑦𝑡=𝑓(𝜂𝜶𝑇𝐤),𝐞𝑡=𝐝𝑡−𝐲𝑡        𝑂(𝑚𝑡−1)   % compute coefficient 𝜶𝑡 using (19)   % save 𝜎pred for 𝜎 tracking   𝜎pred=avg[𝜎pred,avg(𝐝𝐢𝐬)]   % update kernel width σ      𝜎(𝑡)=𝜎(𝑡−1)+𝛾𝜶𝑡𝜶𝑇 (𝐝𝐢𝐬/𝜎3⋅𝐤)          𝑂(𝑚𝑡−1)      if  𝜎 became negative then   % decrease 𝛾 until 𝜎 becomes non-negative   % update kernel width 𝜎 again.   end    if   if (max(𝐤(𝑡−1))≤𝜇0)   % add 𝐱𝑡 to dictionary and update 𝜶 using (23);   else   % update Coefficients 𝜶 using (24);   end if   𝑡=𝑡+1 end for if ( mse𝑙≥𝛿 )   % manipulated step size 𝛾 using (20) else if (mse𝑙−1−mse𝑙<𝜀)  % exit training process end if end while

Algorithm 1 

The adaptive KNN algorithm (AKNN_μ). Complexity for each instance.

3.3. Modulation of Stepsize 𝛾

There are some problems with choosing a fixed 𝛾 that we intend to solve them with a simple way without adding a new procedure. Some of these solutions are as follows:

(𝑎)Preventing Negation of Kernel Width 𝜎. By choosing large 𝛾, large jumps occurs which sometimes lead to 𝜎 passing from positive range to negative range. In order to prevent negation of 𝜎, new 𝜎 value is checked in each time step. If 𝜎 is negative, 𝛾 has been decreased until 𝜎 stays in positive range.

(𝑏)Tracking Kernel Width 𝜎. When current 𝜎 is far from real 𝜎(𝜎_𝑟) and 𝛾 is too small, adaptation procedure cannot reach 𝜎_𝑟 very well. Or when 𝜎 is nearby 𝜎_𝑟, occasionally 𝜎 will be far from 𝜎_𝑟 under a too large 𝛾.

We can track 𝜎 value change by controlling stepsize 𝛾. But when does this problem happen? Assuming that 𝛿 is a danger threshold, we expect that the error learning does not exceed this threshold and MSE_𝑙 is mean square error for 𝑙 instances; if MSE_𝑙≥𝛿, then we can change 𝛾 according to distance of current 𝜎 from 𝜎_𝑟: 𝛾=𝜎_pred−𝜎, (20) where 𝜎_pred is a prediction of 𝜎_𝑟. It means that MSE is too large when 𝛾 is too small to change quickly 𝜎 by (16). So, when 𝜎 is far from 𝜎_𝑟, 𝛾 will increase to σ reaching to 𝜎_𝑟 quickly, or when 𝜎 is nearby 𝜎_𝑟, 𝛾 will decrease for convergence. A simple way for expecting 𝜎_pred is using the average distance of 𝑙 passed instances: 𝜎_pred=^𝑙𝑚_𝑖=1𝑗=1𝐱_𝑖−𝐱_𝑗. (21) According to (10), Gaussian kernel has a good resolution when 0.1<‖𝑥−𝑧‖/𝜎²<10. Therefore, this average could give me an approximation of 𝜎_𝑟.

3.4. Termination Condition

When MSE is an acceptable range (MSE_𝑙<𝛿) and its change is not noticeable (|MSE_𝑙−1−MSE_𝑙|<𝜀), the procedure can be terminated.

3.5. Adaptive Sparsification in KNN

Growing network with arriving training inputs is the other drawback of kernel-based online learning algorithms. In this section, we use a proper criterion to cope with this problem and to produce sparse approximation of functions based on RKHS [22, 23]. As we show, this sparsification approach yields an efficient algorithm that has a linear complexity with respect to the number of dictionary elements. We incorporate the coherence criterion into the new AKNN method to increase the number of variables controlled by the coherence parameter (𝜇₀).

In online coherence-based sparsification algorithm using coherence criterion, whenever a new data pair (𝜑(𝑥_𝑡),𝑑_𝑡) are arrives, a decision is made of whether the new data add to the dictionary 𝑋_𝑚𝑡−1={𝑥_𝑗}^𝑚𝑡−1_𝑗=1. If 𝐤=[𝑘(𝑥₁,𝑥_𝑡),…,𝑘(𝑥_𝑚𝑡−1,𝑥_𝑡)]^𝑇 is kernel vector for 𝑡th instance, the coherence rule has two modes [23].

(a) If max_{𝑗=1⋯𝑚}|𝐤|>𝜇₀. The new instance is not added to 𝑋_𝑚 because 𝜑(𝑥_𝑡) can be reasonably well represented by the kernel functions of the dictionary elements. We suggest a gradient approach for applying effects of removed instance error on dictionary elements coefficients to minimize 𝑒²_𝑡: 𝜕𝑒²_𝑡𝜕𝜶=2𝑒_𝑡𝜕𝑓𝜕𝑢𝜕𝑢𝜕𝜶=2𝐸_𝑡𝜕𝑢𝜕𝜶=𝜂^′𝜶_𝑡𝐤. (22) So, recursive update equation for 𝐸 is obtained by 𝜶(𝑡)=𝜶(𝑡−1)+𝜂^′𝐾_𝑡−1𝜶_𝑡, (23) where 𝜂^′=𝜂/𝑚_𝑡−1 is the stepsize with forgetting factor capability.

(b) If max_{𝑗=1⋯𝑚}|𝐤|≤𝜇₀. The new instance is added to 𝑋_𝑚 and 𝜶 vector is updated by 𝜶(𝑡)=𝜶()0𝑡−1+𝜂^′𝐾_𝑡−11𝜶_𝑡. (24) Adaptive kernel width and sparsity techniques in KNN method (AKNN_μ) which is described in Algorithm 1, are produced from combination of this online sparsification strategy with AKNN methods. This algorithm has high accuracy because errors of removed instances are committed in learning process, and it is capable of online application. Algorithm 1 shows that its complexity for each instance is 𝑂(𝑚), if 𝑚 is the number of dictionaries.

4. Experiments and Results

Two experiments have been designed. In the first experiment effects of kernel width parameter on performance of the proposed KNN method with adaptive kernel width and the KNN method with fixed kernel width were demonstrated. In the second experiment, simulations on some classification problems to compare performance of the proposed method with other online classification methods were conducted.

4.1. Evaluation Effect of Parameter 𝜎 on the Fixed and Adaptive KNN Methods

This experiment is an example that visualizes effect of choosing initial 𝜎 on learning error. It was performed on an artificial two-dimensional (2D) dataset with 720 samples (Figure 2), whose design is complex. A comparison was carried out between the performance of the adaptive kernel width KNN method and the fixed kernel width KNN approach in the same conditions. The plot of Figure 3 depicts the average square error rate in both methods for small (Figure 3(a)) and large 𝜎 (Figure 3(b)). The changing process of 𝜎 in each time step of online learning algorithm in AKNN is plotted in Figure 4(a) (for small 𝜎) and in Figure 4(b) (for large 𝜎).

Figure 2 

Spiral dataset by 800 instances.

(a)

(b)

Figure 3 

Evolution curves of the MSE of KNN and AKNN methods for (a) 𝜎=0.001, (b) 𝜎=1.

(a)

(b)

Figure 4 

Evolution curves of the 𝜎 changes in AKNN method for different (a) 𝜎=0.001, (b) 𝜎=1.

The empirical feature space preserves the geometrical structure of Φ in the feature space [11, 26]. Figure 5 gives the 2D projection of the training data (90% of data) in the empirical feature space when the Gaussian kernel function with different 𝜎 is employed. It is based on only the 2D projection of the embedding that means the first two largest eigenvalues of kernel Gram matrix. Classification results of testing data (10% of data) for three 𝜎 values are presented in Figure 6 that shows misclassified data by circles.

(a) 𝜎=0.001

(b) 𝜎=0.14

(c) 𝜎=1

Figure 5 

Classification result of KNN method for different values of 𝜎.

(a) 𝜎=0.001

(b) 𝜎=0.14

(c) 𝜎=1

Figure 6 

Two-dimensional projection in empirical feature space for different initial values of 𝜎.

Figure 3 demonstrates the effects of initial 𝜎 change on the MSE changing process for both methods. We observe that AKNN achieves significantly smaller MSE than the KNN algorithm in both cases. This shows that the proposed AKNN approach is effective for different initial 𝜎 values and can reach appropriate 𝜎 value (from Figure 4). Achieved 𝜎 from AKNN approach for spiral dataset is about 0.14. In addition, effect of 𝜎 on result classification is shown clearly in Figure 6. It means that KNN too has misclassified data for inappropriate 𝜎 and least misclassified data for the best 𝜎 that the achieved from proposed method.

Figure 5 gets some intuitive feeling about the position of data into the empirical feature space. From Figure 5(b), it is seen that the embedded data are too dense in empirical feature space and they cannot explain class separability. In Figure 5(c) with large 𝜎, the embedded data are not dense, but they have complex structure yet that cannot be separated by linear hyper plans. Opposed to the two mentioned cases, the embedded data have a good resolution and a linear structure that can be separated by linear hyper plans.

4.2. Performance Comparison of AKNN with Online Learning Methods

The experiments have been carried out to evaluate the performance of the proposed method in comparison with a number of online classification methods. They include the kernel perception algorithm [25], the aggressive version of ROMMA [27], the ALMA_𝑝(𝛼) algorithm [28], and the passive-aggressive algorithms (PA) [29]. We test all the algorithms on ten real datasets which are listed in Table 2 and can be downloaded from LIBSVM, UCI, and MIT CBCL face websites.

Table 2 

Datasets used in the experiments.

To make a fair comparison, all algorithms adopt the same experimental setup. For all algorithms in comparison, we set the penalty parameter 𝐶=5 and train all datasets with the Gaussian kernel with 𝜎=8. For the ALMA_𝑝(𝛼) algorithm, parameters 𝑝 and 𝛼 are set to 2 and 0.9, respectively. We fix sparsity threshold to be 0.7 (𝜌 in DUOL algorithm and μ in AKNN_μ).

We scale all training and testing data to be in [0,1]. Then we use a 10-fold cross-validation to estimate the efficiency measurements the same as mistake rate, density rate, and running time. The mistake rate evaluates the online learning performance that is the percentage of instances that are misclassified by the learning algorithm. We measure the sparsity of the learned classifiers by the density rate that is the percentage of remained instances (or support vectors in some of the methods). The running time evaluates computational efficiencies of all the algorithms. All the experiments are run in MATLAB over a windows machine.

Table 3 presents the result of comparing eight online learning algorithms over the large datasets. And Table 4 summarizes the performance of six compared online learning algorithms over the small and medium datasets. KNN and AKNN methods are not in Table 3 because they do not have sparsification technique. The online learning efficiency measurements are presented in both tables.

Table 3 

Evaluation of online learning algorithms with sparsing ability on the large datasets.

Table 4 

Evaluation of online learning algorithms on the small and medium datasets.

According to the experimental results shown in Tables 3 and 4, we can see that(i)although there is little difference in the training mistake rate among all methods, the proposed method has the best training mistake rate especially for large datasets;(ii)the proposed method achieves significantly smaller testing mistake rates than the other online approaches except in pima dataset;(iii)it can be seen that the perceptron, ALMA, and AKNN_μ methods return more density rate than other approaches especially for large datasets. That means they need to keep fewer training data. Therefore, we can say that these methods are faster than other approaches because in general the training time is proportional to the size of dictionary.

So, we can say that among all online learning, the AKNN_μ method yields the least mistake rate with the smallest density rate and running time for most of the cases. It happens because AKNN_μ method is able to find a proper kernel function by finding the best kernel parameters and it keep the least and the best possible instances that are selected by online sparsification method.

5. Conclusion and Future Works

The goal of the present paper was to present a novel adaptive kernel least-mean-square neural network method. This method (AKNN) has an adaptive kernel width and sparsification processes simultaneously. We briefly touched history of learning algorithms based on LS. Then, we proposed an adaptive kernel that iteratively decreases least mean square error in form (4) to select proper kernel width for Gaussian kernel. For improving the method in online application, we have used a sparsification methodology for controlling the model order increasing that its computational complexity is only linear in the dictionary size. By use of the acquired μ-coherence dictionary from the training samples, the algorithm needs less computational cost and memory requirement compared with conventional KNN. The conducted experiments show that varying σ did not affect the proposed algorithm. Experiments results also prove that the given algorithm has faster learning rate than conventional KNN algorithm and better classification performance than other online classification methods. However, selecting proper values for other parameters is still a challenge.

Our future works deal with the following questions: can we use a more efficient function as the sigmoid function in the KNN neuron? Can we adapt other kernel functions to use in neuron KNN? How to improve the performance of AKNN on imbalanced data and noisy data?