Grey adaptive growing CMAC network

Applied Soft Computing 11 (2011) 5400–5410

Contents lists available at ScienceDirect

Applied Soft Computing journal homepage: www.elsevier.com/locate/asoc

Grey adaptive growing CMAC network Ming-Feng Yeh ∗ , Min-Shyang Leu Department of Electrical Engineering, Lunghwa University of Science and Technology, 33306 Taoyuan, Taiwan

a r t i c l e

i n f o

Article history: Received 20 July 2009 Received in revised form 31 August 2010 Accepted 2 May 2011 Available online 20 May 2011 Keywords: Cerebellar model articulation controller Grey relational analysis Tree structure Adaptive quantization

a b s t r a c t This study attempts to develop a grey adaptive growing cerebellar model articulation controller (CMAC) network, which is constructed by connecting several 1D Albus’ CMACs as a two-level tree structure. Even though the target function is unknown in advance, grey relational analysis still can analyze the learning performance between the network outputs and the target values. According to the result of grey relational analysis, the proposed adaptive growing mechanism could determine whether a specific region covered by a state or a CMAC needs to be repartitioned or not. By this way, not only the number of 1D CMACs but also the number of states could be gradually increased during the learning process. And then the purpose of self-organizing input space can be attained. In addition, the linear interpolation scheme is applied to calculate the network output and for simultaneously improving the learning performance and the generalization ability. Simulation results show that the proposed network not only has the adaptive quantization ability, but also can achieve a better learning accuracy and a good generalization ability with less memory requirement. © 2011 Elsevier B.V. All rights reserved.

1. Introduction Cerebellar model articulation controller (CMAC) network, proposed by Albus [1,2], is a kind of supervised neural network inspired by the human cerebellum. Unlike multilayer perceptron networks, CMAC network learns input–output mappings based on the premise that similar inputs should produce similar outputs. Hence it stores information locally in a way that the learned information can be easily recalled but use less memories. Owing to its fast learning speed, good generalization ability and ease of implementation by hardware, the CMAC network has been successfully applied in the control problem [3–6]. The basis function of CMAC network can be categorized into two main types. One is the constant basis function [1]. The other is the non-constant differentiable basis function such as Gaussian function or B-Spline function [7]. CMAC network with constant basis function is also termed Albus’ or conventional CMAC, while with differentiable basis function is simply termed differentiable CMAC hereafter. Not only Albus’ CMAC but also differentiable CMAC has two major limitations: enormous memory requirement for solving high-dimensional problem and difficult in selecting the memory structure parameters [8]. To reduce enormous memory requirement, Lin and Li [9] presented a tree-type CMAC structure composed of a set of submodules constructed by several twodimensional (2D) Albus’ CMACs. Each 2D CMAC in a submodule has

∗ Corresponding author. Tel.: +886 2 82093211x5501; fax: +886 2 82099728. E-mail address: [email protected] (M.-F. Yeh). 1568-4946/$ – see front matter © 2011 Elsevier B.V. All rights reserved. doi:10.1016/j.asoc.2011.05.019

a subset of the system inputs as its input variables. The network output is the sum of the outputs from a set of submodules. Lee et al. [8] proposed a supervised hierarchical CMAC (HCMAC) network composed of 2D differentiable CMACs in the structure of full binary tree topology to reduce the memory requirement. Rather than using 2D CMACs in the network structure, Hung and Jan [10] developed a macro structure CMAC (MS CMAC) by connecting several 1D conventional CMACs as a tree structure to reduce the computational complexity in multidimensional CMAC. Further studies of MS CMAC network can be found in [11,12]. On the other hand, the input space quantization of a CMAC network will affect its memory structure parameters. Since the clustering methods could reduce the memory requirement for high dimensional problem, several researcheres proposed the feasibility of applying clustering techniques to obtain adaptive resolution for input space quantization [8,13–16]. The literatures stated in above can solve at least one of two major limitations of CMAC network. In general, those CMACs with the ability to self-construct or self-organize input space are the ones with differentiable basis function [8,13–16]. In other words, most of Albus’ CMACs are lack of such a ability. This gives rise to the motivation to develop a self-organizing approach for Albus’ CMAC. However, since the output of CMAC network is always constant, the derivative information of input and output variables cannot be preserved. As a result, the gradient-descent learning rule cannot be applied to update the memory contents of Albus’ CMAC and to self-organize the input space. Based on grey relational analysis [17], this study attempts to propose a new kind of 2D CMAC network, termed the grey adaptive growing CMAC network (GAG-CMAC), to

M.-F. Yeh, M.-S. Leu / Applied Soft Computing 11 (2011) 5400–5410

simultaneously achieve the purpose of self-organizing input space and overcome those two major limitations. Generally speaking, the differentiable CMAC has a better learning accuracy and generalization ability than Albus’ CMAC [7]. The memory requirement of the former, however, is larger than that of the latter. Herein the memory requirement is defined as the number of memory elements to store all adjustable parameters such as the memory contents of CMAC network and the mean and variance of each Gaussian basis function. In order to construct the proposed network with less memory requirement, it is on the basis of Albus’ CMAC. Hereafter, for abbreviation, this study uses CMAC instead of Albus’ CMAC network unless it is necessary to be specified. Besides, this study also applies the linear interpolation scheme to the recall process of CMAC network so as to reduce both the learning error and the generalization error caused by quantization. The proposed GAG-CMAC network is constructed by several 1D CMACs as MS CMAC network, but its learning process (also called the adaptive growing process) contains two adaptive growing stages. The first one is the state growth stage which is used to adaptively quantize the domain of one direction, say x-axis. Different 1D CMACs may have different quantization results. The second one is the CMAC growth stage which is used to adaptively quantize the domain of another direction, say y-axis. In addition, this study also applies grey relational analysis [17] into such two growing mechanisms. Even though the target function is unknown in advance, grey relational analysis still can analyze the learning performance between the network outputs and the target values. Then the relational grade corresponding to a specific region covered by a state or a CMAC is employed to evaluate whether that region needs to be repartitioned or not. By this way, not only the number of 1D CMACs but also the number of states could be gradually increased during the learning process. With the help of these two adaptive growing stages, the purpose of selforganizing input space could be attained. Note that this study only focuses on the 2D problem because the multidimensional problems can be solved by use of the hierarchical structure as HCMAC network [8]. The remainder of this paper is organized as follows. Section 2 briefly represents some background material such as grey relational analysis and CMAC networks. The proposed GAG-CMAC network is given in Section 3. Section 4 shows the simulation results of two examples. Finally, Section 5 contains some conclusions of this study.

2. Grey relational analysis and CMAC networks 2.1. Grey relational analysis Grey relational analysis is a similarity measure for finite sequences with incomplete information [17]. For a given reference vector and a given set of comparative vectors, grey relational analysis can be used to determine the relational grade between the reference and each element in the given set. Then the most similar vector in the comparative set to the reference can be found by further analyzing the resultant relational grades. In other words, grey relational analysis can be viewed as a measure of similarity for vectors of finite dimensions. (r) (r) (r) Denote the reference sequence by v(r) = (v1 , v2 , ..., vn ) and (i)

(i)

(i)

the ith comparative sequence by v(i) = (v1 , v2 , ..., vn ), i = 1, 2, . . ., m. Then the grey relational coefficient between v(r) and v(i) at the jth component, j = 1, 2, . . ., n, is defined as follows: (r)

(i)

r(vj , vj ) =

min + max , ij + max

(1)

5401

Fig. 1. Architecture of CMAC network.

 

(r)

(i)

where ij = vj − vj

   , max = maxmaxij , min = minminij , i

i

j

j

and ␰∈(0,1] is the distinguishing coefficient controlling the resolution between max and min . The corresponding grey relational grade is g(v(r) , v(i) ) =

n 

(r)

(i)

wj r(vj , vj ),

j=1

(2)

n

where wj ≥ 0 is the weighting factor satisfying w = 1. Norj=1 j mally, we select it as wj = 1/n for all j. The best comparative sequence to the reference is the one with the largest relational (r) (i) grade. Note that we can always guarantee that 0 < r(vj , vj ) ≤ 1 and 0 < g(v(r) ,v(i) ) ≤ 1. 2.2. Albus’ CMAC network In a CMAC network, each state variable is quantized and the problem space is divided into discrete states [1,2]. A vector of quantized input values specifies a discrete state and is used to generate addresses for retrieving information from memory elements for this state. The basic structure of CMAC is depicted in Fig. 1. In the figure, the association memory A is obtained from the input space S, the associated data stored in the memory cell W are yielded in accordance with each input state. The CMAC sums the mapped data up as its output and feeds the error between the actual and desired outputs back to the memory cell equally. Assume that the input space S is quantized into Ns states and every state utilizes Ne memory units to store the corresponding memory contents. Furthermore, assume that the number of memory units is Nmem . Owing to Albus’s CMAC network without using the Gaussian function as its basis function, a memory unit consists of one and only one memory element which is to store the memory content of the network. That is to say, Nmem is equal to the number of memory elements. The stored data yk (the actual output of the CMAC) for the state sk is the sum of stored contents of all addressed memory units and can be expressed as



Nmem

yk = ak w =

ak,l wl ,

(3)

l=1

where wl , l = 1, 2, . . ., Nmem , is the memory content of the lth memory unit, w = [w1 , w2 , . . ., wNmem ]T , ak,l is the association index indicating whether the lth memory unit is addressed by the state sk or not, and ak = [ak,1, ak,2 , . . ., ak,Nmem ]. Since each state addresses exactly Ne memory units, only those addressed ak,l ’s are 1, and the others are 0. The CMAC uses a supervised learning method to adjust the memory contents during each learning cycle. Its updating rule can be described as  T w(t + 1) = w(t) + a [ˆy − ak w(t)], t = 1, 2, 3, ... (4) Ne k k

5402

M.-F. Yeh, M.-S. Leu / Applied Soft Computing 11 (2011) 5400–5410

a physical memory address. Information for a discrete state is distributively stored in memory units associated with the hypercubes being addressed. The entire memory size, equal to the number of hypercubes denoted by Nh , of 2D CMAC network can be determined by Nnem = Nh =

Fig. 2. Block division of 1D CMAC network.

(5)

where A+ = AT (AAT )−1 is the pseudo-inverse of the association matrix A formed from the association vector ak , k = 1, 2, . . ., Ns , T as row vector, and yˆ = [ˆy1 , yˆ 2 , ..., yˆ Ns ]. That is to say, the updating rule (2) could converge to w* if the learning rate is properly selected [18]. Fig. 2 illustrates a simple block division for a single variable case. In the figure, the input space is quantized into seven states (Ns = 7) and every state utilizes three memory units to store its information (Ne = 3). By this way, there are three discrete regions, called blocks, in each layer. For a 1D CMAC network, information for a discrete state is distributively stored in memory units associated with the addressed blocks. For example, three blocks, A, E, and H, are addressed by the state s3 . Therefore, information for the state s3 is stored in the memory units associated with those three blocks. Besides, the entire memory size, equal to the number of blocks denoted by Nb , of 1D CMAC network can be determined by Nmem = Nb = Ns + Ne−1 .

Nb1 (L)Nb2 (L),

(7)

L=1

where w(t + 1) is the memory content at time t + 1, w(t) is the one at previous time t,  is the learning rate, yˆ k is the desired value for the state sk , and yˆ k − ak w(t) is the error for the state sk . Note that only the addressed blocks are updated. On the other hand, the analytical solution of w is w∗ = A+ yˆ ,

Ne 

(6)

On the other hand, Fig. 3 shows a simple block division for a two-variable case. This simple example has two state variables with each quantized into seven elements. If every state also utilizes three memory units to store its information, then there are three discrete blocks in each layer. Areas, such as Bb, Ee, and Ih, formed by quantized regions are called hypercubes. Only the blocks on the same layer can be combined to form a hypercube. It can be seen from Fig. 3 that each state is covered by three different hypercubes, one from each layer. For example, three hypercubes, Bb, Ee, and Ih, are addressed by the state located on (5,4). Unlike the 1D CMAC network, a 2D CMAC network associates each hypercube to

where Nb1 (L) and Nb2 (L) represent the number of blocks at the Lth layer for x1 and x2 , respectively. 2.3. CMAC with Gaussian basis function Consider an Nv -dimensional Gaussian CMAC. A Gaussian basis function with Nv -dimension is included so that the recall rule (3) is revised to be (8) as follows.



Nmem

y(s) =



al (s)wl



Nv 

l=1

l (si ) ,

(8)

i=1

where s is a specific input state, si denotes the input value of the ith dimension for s, Nmem denotes the number of memory units, al (s) is the lth element of association memory selection vector for s, wl is the memory content of the lth memory unit, and l (si ) represents the Gaussian basis function of the lth memory unit corresponding to the ith input variable described as follows:



l (si ) = exp −

(si − mli )2 li



,

(9)

where mli and  li are the mean and variance of the basis function, respectively. The memory content wl , l = 1, 2, . . ., Nmem , as well as the corresponding mean and variance, mli and  li , i = 1, 2, . . ., Nv , are the adjustable parameters in a Gaussian CMAC. To store all adjustable parameters of the network, a memory unit must consist of 1 + 2Nv memory elements. Hence the entire memory requirement is Nmem (1 + 2Nv ). Note that the entire memory requirement of Albus’ CMAC is Nmem . As can be seen, the memory requirement of Gaussian CMAC is larger than that of Albus’ CMAC. For deriving the updating rule, an error cost function E is defined as follows: E=

1 2 (ˆy(s) − y(s)) , 2

(10)

where yˆ (s) is the desired output value for the input state s. With this error function, the gradient descent method can be employed to infer the learning rules for the adjustable parameters. The learning rules are summarized as follows. (1) The updating rule for the ith memory content can be derived as

  ∂E  = (ˆy(s) − y(s)) · al (s) · l (si ), Ne ∂wl Ne Nv

wl = −

(11)

i=1

where wl is the updated value of the lth memory content. (2) The updating rule for the mean and variance of the Gaussian basis function can be derived as mli = −

 ∂E  = (ˆy(s) − y(s)) · al (s) · wl · Ne ∂mli Ne

Nv 

l (si ) ·

i=1

li = −

 ∂E  = (ˆy(s) − y(s)) · al (s) · wl · Ne ∂li Ne

Nv 

l (si ) ·

i=1

Fig. 3. Block division of 2D CMAC network.

2(si − mli ) li2

2(si − mli ) li3

,

(12)

,

(13)

2

where mli and  li are the updated values for the mean mli and variance  li of the Gaussian basis function i , respectively.

M.-F. Yeh, M.-S. Leu / Applied Soft Computing 11 (2011) 5400–5410

5403

Fig. 5. Input space quantization of GAG-CMAC network.

Fig. 4. Structure of GAG-CMAC network.

3. Grey adaptive growing CMAC network 3.1. Network structure Fig. 4 depicts the structure of the proposed GAG-CMAC network. In the figure, each node Ci , i = 1, 2, . . ., M, in the second layer is implemented by a 1D CMAC network and therefore is termed a CMAC node. In the first layer, an active index node, say bi , plays the role of indicating the corresponding CMAC node is active or not. If the ith CMAC is active, then bi = 1; otherwise, bi = 0. Only those active CMACs could deliver their outputs to the next layer. The final layer contains only one interpolation node I which just performs the linear interpolation on its receiving values to obtain the network output. Although the proposed structure is similar to the two-level tree structure of MS CMAC network, four main differences between them could be briefly stated as follows. (1) The root node in the MS CMAC is a 1D CMAC, but the proposed network is an interpolation node. (2) All of CMAC nodes in the GAG-CMAC network could be dynamically updated in utilizing, but the leaf nodes in the MS CMAC network are static. Other nodes in the MS CMAC network are still dynamical. (3) The GAG-CMAC network is a kind of feed-forward network. The network output can be directly obtained from the network structure. However, the time inversion technology must be applied to the MS CMAC network to acquire the network output. (4) The GAG-CMAC network allows both the number of states and the number of 1D CMACs to be gradually increased during the learning process, but the MS CMAC network cannot. On the other hand, those CMAC nodes in the GAG-CMAC network could partition the 2D input space into several subspaces. Fig. 5 demonstrates a possible quantization of the input space using by the proposed network. Assume that the ith CMAC, i = 1, 2, . . ., M, is quantized into Ns(i) states by the knots qi,j ’s, j = 0, 1, 2, . . ., Ns(i) and the considered 2D input space is S = [x1L , x1U ] × [x2L , x2U ], where the superscripts L and U represent the lower and upper bounds of the M N states input variable x1 or x2 , respectively. Then there are i=1 s(i) in the input space S. The subspace [gi−1 , gi ] × [x2L , x2U ]:=Ri represents the region covered by the ith CMAC, where the knots on the x1 -axis, i.e., gi ’s, are used to partition the domain [x1L , x1U ]. Note that

the region Ri is not the input space of the ith CMAC. In fact, the input space of any 1D CMAC in this example is [x2L , x2U ]. Besides, the area formed by [gi−1 , gi ] × [qi,j−1 , qi,j ] := Ui × Vi,j represents the quantization region associated with the jth state of the ith CMAC. Hereafter, for abbreviation, we use the notation si,j to represent the jth state of the ith CMAC. See Fig. 5 for example again, the grey cell represents the region covered by the state s3,2 . 3.2. Virtual training patterns Let p˛,ˇ = (x1,˛ , x2,ˇ ) be a given input pair in S, where ˛ = 1, 2, . . ., Np1 and ˇ = 1, 2, . . ., Np2 . Then there are Np1 × Np2 given pairs in S. The input points x1,˛ ’s could be randomly or uniformly distributed in the domain [x1L , x1U ], while x2,ˇ ’s in [x2L , x2U ]. Each input pair is associated with a target value d˛,ˇ generated from the target function f(x1,˛ , x2,ˇ ). Without lost of generality, it is assumed that each state contains at least one input pair. In order to reduce the computational complexity and hasten the learning speed during the adaptive growing process, a set of virtual training patterns generated from the given patterns is used in this study. Denote p¯ i,j as the virtual input pair for the state si,j and d¯ i,j as the corresponding target value, where the values of p¯ i,j and d¯ i,j are defined by p¯ i,j =

d¯ i,j =

1 N(si,j ) 1 N(si,j )



p˛,ˇ ,

(14)

d˛,ˇ ,

(15)

p˛,ˇ ∈ si,j

 p˛,ˇ ∈ si,j

in which N(si,j ) represents the number of the input pairs belonging to the state si,j . Then the pair (p¯ i,j , d¯ i,j ) forms a virtual training pattern. In Fig. 5, the black triangle in each cell represents the corresponding virtual input pair. As can be seen, there are exactly M N virtual input pairs and no two distinct pairs are assoi=1 s(i) ciated with the same state. Those virtual pairs located in the region covered by the ith CMAC are used to train that CMAC only. In other words, such virtual training patterns not only allow a CMAC to be trained with a few instances, but also could avoid the learning interference [19] during the training process. On the other hand, since p¯ i,j is the average value of all input pairs belonging to the state si,j , it can be regarded as the center of that state and is in the form of i ). The pair (¯ i ) also reveals that the x elements of all (¯x1,i , x¯ 2,j x1,i , x¯ 2,j 1 state centers belonging to a specific CMAC are identical, but the x2 elements may be different for different CMACs.

5404

M.-F. Yeh, M.-S. Leu / Applied Soft Computing 11 (2011) 5400–5410

3.4. Adaptive growing process The proposed adaptive growing process involves two main stages. One is the state growth stage. The other is the CMAC growth stage. The latter always follows the former during the adaptive growing process. Learning starts with the network composed of a small number of CMAC nodes, say M = 2, 3, or 4, and the input space of each 1D CMAC is quantized into several states. Those 1D CMACs could quantize the problem space into several discrete states as shown in Fig. 5.

Fig. 6. Relation between the temporary pairs and the input pair.

3.3. Network operations Without lost of generality, the active parameter for each 1D CMAC in the proposed network hereafter is assumed to be x2 . This means that the output of any 1D CMAC is only depended on the value of x2 . When an arbitrary input pair, say p = (x1 , x2 ), is applied to the proposed network, the temporary pairs generated from the input pair are used to determine which CMACs are active. Assume that p ∈ si,j . The relation between the temporary pairs and the given input pair is depicted in Fig. 6. In general, an input pair will generate two temporary pairs: one is ti (¯x1,i , x2 ) ∈ si,j and the other is ti−1 = (¯x1,i−1 , x2 ) ∈ si−1,k . These two temporary pairs, located in adjacent states but in different CMACs, could indicate which CMACs are active. In this case there exist two active CMACs, i.e., bi = bi−1 = 1. However, when x1 < x¯ 1,1 or x1 > x¯ 1,M , there is only one temporary pair, (¯x1,1 , x2 ) or (¯x1,M , x2 ), to be generated. At this situation, only one CMAC is active. To sum up, determining which CMACs are active can be simply represented by



if x1 < x¯ 1,1 , then b1 = 1. if x¯ 1,i−1 ≤ x1 ≤ x¯ 1,i , i = 2, 3, ..., M, then bi = bi−1 = 1. (16) if x1 > x¯ 1,M , then bM = 1.

Note that those CMACs which are not identified as active are inactive. Once all active index nodes are determined, the output of each CMAC node can be represented by oi (x1 , x2 ) = bi (x1 )Ci (x2 ),

i = 1, 2, . . . , M,

(17)

where bi (x1 ) denotes the output of the ith active index node due to the input element x1 and Ci (x2 ) represents the output of the ith CMAC due to x2 . The node output oi (x1 , x2 ) also represents the output of the ith CMAC, but due to the input pair (x1 , x2 ). Note that only those active CMACs could deliver their outputs to the final layer for interpolation. Finally, the node I performs the linear interpolation on its receiving values to obtain the network output as follows.

⎧ ⎨ o1 ,

y(x1 , x2 )

=

x¯ 1,i − x1

⎩ x¯ 1,i − x¯ 1,i−1 oM,

oi−1 +

x1 − x¯ 1,i−1 x¯ 1,i − x¯ 1,i−1

if x1 < x¯ 1,1 , oi ,

if x¯ 1,i−1 ≤ x1 ≤ x¯ 1,i ,

(18)

if x1 > x¯ 1,M ,

where 1 < i ≤ M. It can be seen from (16) that the interpolation node receives at most two values.

3.4.1. Outputs of CMAC nodes Once the 2D input space is quantized, all virtual training patterns could be determined by (14) and (15). Then letting yˆ j = d¯ i,j , j = 1, 2, . . ., Ns(i) , and using the pseudo-inverse scheme (5) could attain the memory contents of the ith CMAC, i = 1, 2, . . ., M. That is the so-called one-step training rule for any CMAC node in the proposed network. Subsequently, the actual output of the state si,j , denoted by y¯ i,j , can be determined by (3). Any input pair belonging to the state si,j will result in an identical output with value of y¯ i,j . In order reduce the generalization error caused by quantization, the CMAC output Ci (x2 ) herein is obtained by applying the linear interpolation scheme to the recall rule (3). That is to say, at the virtual training inputs, the responses equal with the corresponding actual outputs, whereas in between, the response is obtained by linear interpolation. The corresponding mathematical expression is

Ci (x2 ) =

⎧ y¯ i,1 , ⎪ ⎨ x¯ i

2,j

− x2

x¯ i − x¯ i ⎪ ⎩ y¯ 2,j 2,j−1 i,Ns(i) ,

y¯ i,j−1 +

i x2 − x¯ 2,j−1 i i x¯ 2,j − x¯ 2,j−1

i if x2 ≤ x¯ 2,1 ,

y¯ i,j ,

i i if x¯ 2,j−1 < x2 ≤ x¯ 2,j ,

if

x2

>

(19)

i x¯ 2,N . s(i)

3.4.2. State growth stage This study utilizes the learned information of a CMAC to determine which states in that CMAC need to be repartitioned or not. With the help of repartitioning some states, the number of states could be gradually increased; meanwhile, the purpose of adaptive quantization can be attained. Fig. 7 simply illustrates the concept of state growth process for the ith CMAC, where each state is covered by three different blocks, i.e., Ne = 3. That CMAC starts with four states and successively creates one new state during the state growth process. Assume that the state si,2 in Fig. 7(a) is selected to be repartitioned. Inserting a new knot into that state, as shown in Fig. 7(b), could attain the purpose of state growth. Herein the newly inserted knot is simply placed at the center of that state. Other possible location is allowable. The succeeding state growth step is to insert a new knot into the fifth state in Fig. 7(b) and the new block division is given in Fig. 7(c). Each state growth step leads to the entire memory size being increased by one and each grey box represents the newly created block (memory unit) at every growth step. As can be seen, the newly created block is always appended to the complete block. Except blocks A and B, other incomplete blocks are extended to cover one more state until they become the complete ones. For example, in Fig. 7(a), D is a complete block, but E and F are incomplete blocks which cover two and one states, respectively. After creating one new state, a new block G is appended to D, while E and F become covering three and two states, respectively, as shown in Fig. 7(b). By inspecting the node output (19), the CMAC output is only dependent upon the x2 element of a given input pair. For a specific CMAC, those input pairs with the same x2 element will produce an identical output, but their corresponding target values may be different. To evaluate the learning performance of every state in a

M.-F. Yeh, M.-S. Leu / Applied Soft Computing 11 (2011) 5400–5410

5405

Fig. 7. State growth process.

specific CMAC by grey relational analysis, those target values are replaced by a temporary value defined as their average value, i.e., d˜ i,ˇ =

1 N(Ui )



d˛,ˇ =

x1,˛ ∈ Ui

1 N(Ui )



f (x1,˛ , x2,ˇ ),

(20)

x1,˛ ∈ Ui

where N(Ui ) represents the number of the input points x1,˛ ’s in the region Ui = [gi−1 , gi ]. By this definition, the temporary value d˜ i,ˇ could be regarded as the target value corresponding to the CMAC output Ci (x2,ˇ ). Let the reference sequence be constructed by

i and it can divide the state si,j into two states as as the point x¯ 2,j depicted in Fig. 7. To do so, the proposed approach could simultaneously attain the purposes of adaptive quantization and state growth. The state growth process will stop when a specified performance measure or a pre-specified maximum number of states (or epochs) is reached. The algorithm for the state growth process of the ith CMAC is presented below.

Algorithm 1.

State growth algorithm.

(r)

those temporary target values belonging to the ith CMAC, i.e., vi = (d˜ i,1 , d˜ i,2 , ..., d˜ i,N ) and a single comparative sequence be formed p2

by

(c) vi

= (Ci (x2,1 ), Ci (x2,2 ), ..., Ci (x2,Np2 )). Then the grey relational

coefficient r(d˜ i,ˇ , Ci (x2,ˇ )), ˇ = 1, 2, . . ., Np2 , can be obtained by (1). (r)

(c)

Although the grey relational grade g(vi , vi ) attained by (2) could represent the similarity measure between the reference sequence (r) (c) vi and the comparative sequence vi , it cannot clearly indicate the relational grade for each individual state. Rather than using (2), the grey relational grade for the jth state of the ith CMAC is defined as (r)

(c)

gj (vi , vi ) =

1 N(Vi,j )



r(d˜ i,ˇ , Ci (x2,ˇ )):=g(si,j ),

(21)

Step 1. Generate the virtual training patterns by (14) and (15). Step 2. Obtain the memory contents by the pseudo-inverse scheme (5). Step 3. Use (19) to find all CMAC outputs. Step 4. Determine whether the stopping criterion of the state growth process is fulfilled. If fulfill, terminate the process; otherwise, go to Step 5. Step 5. Compute the grey relational grade for each state by (21). Step 6. Insert a new knot into the state satisfied the evolution criterion for state growth, and then return to Step 1. If there are more than one state to be repartitioned, each associated interval must be inserted a corresponding new knot.

x2,ˇ ∈ Vi,j

where N(Vi,j ) represents the number of the input points x2,ˇ ’s in the region Vi,j = [qi,j−1 , qi,j ]. Note that it is also true that 0 < g(si,j ) ≤ 1. (r)

Owing to the reference sequence vi directly generated from the given target values, the relational grades g(si,j )’s can be still obtained by (21) even if the target function is unknown. The larger the relational grade of a state, the better the learning performance for that state. Hence, those states with smaller relational grade (worse learning result) must be further quantized to minimize the generalization error caused by quantization. The evaluation criterion is that a state, say si,j , needs to be repartitioned if g(si,j ) ≤ , where  is a predefined repartition threshold i ≤ q , where x i ¯ 2,j and 0 <  ≤ 1. Since qi,j−1 ≤ x¯ 2,j is the x2 element i,j i into the interof the virtual input pair p¯ i,j , inserting the point x¯ 2,j val [qi,j−1 , qi,j ] could divide that interval into two parts. Hence, the newly inserted knot for the state si,j in this study is directly assigned

Once any state is repartitioned, the virtual training patterns must be regenerated by (14) and (15) according to the newly quantized space. And then following Algorithm 1 performs the rest steps of the state growth process. Besides, each CMAC has its own state growth process. Different CMACs therefore may have different quantization results as illustrated in Fig. 5. 3.4.3. CMAC growth stage When the state growth stage is terminated, the learned information, such as the memory contents and the quantization result of the input space, is treated as the initial conditions of the CMAC growth stage. When the input pair p˛,ˇ = (x1,˛ , x2,ˇ ) is applied to the proposed network, the corresponding network output, denoted by y˛,ˇ , can be obtained by (18). Let Y = [y˛,ˇ ] be the comparative matrix and D = [d˛,ˇ ] be the reference matrix. Both matrices are of size Np1 × Np2 . Analogous to the original grey relational analysis,

5406

M.-F. Yeh, M.-S. Leu / Applied Soft Computing 11 (2011) 5400–5410

the grey relational coefficient between two matrices D and Y at the ˛ˇth component can be defined as follows: rˆ (d˛,ˇ , y˛,ˇ ) = where

ımin + ımax , ı˛ˇ + ımax





ı˛ˇ = d˛,ˇ − y˛,ˇ  ,

(22) ımax = maxmaxı˛ˇ , ˛

ˇ

ımin =

minminı˛ˇ , and ∈ (0, 1] is the distinguishing coefficient ˛

ˇ

controlling the resolution between ımax and ımin . Note that 0 < rˆ (d˛,ˇ , y˛,ˇ ) ≤ 1. Since the network output generally is the linear interpolation of two adjacent CMAC outputs, rather than computing the relational grade for each CMAC, the evaluation criterion for CMAC growth is aimed at calculating the relational grade for each interpolation region as stated as follows. Let x¯ 1,0 = x1L and x¯ 1,M+1 = x1U , and define the ith interpolation region as R¯ i = [¯x1,i−1 , x¯ 1,i ] × [x2L , x2U ], i = 1, 2, . . ., M + 1. It can be seen from Fig. 6 that the interpolation region R¯ i , i = / 1 and M + 1, are associated with the (i − 1)th and ith CMACs. Note that the outmost regions, R¯ 1 and R¯ M+1 , is covered by only a single CMAC, i.e., the first and the last one, respectively. The grey relational grade for the kth interpolation region is defined as gˆ (R¯ k ) =

1 N(R¯ k )



rˆ (d˛,ˇ , y˛,ˇ ),

(23)

p˛,ˇ ∈ R¯ k

where N(R¯ k ) represents the number of input pairs in the region R¯ k . If gˆ (R¯ k ) ≤ ε, where ε is a predefined repartition threshold for the CMAC growth process, then the repartition interval is the interval covered the (k − 1)th and kth CMACs, i.e., [gk−2 , gk ]. It is possible that there are ,  ≥ 1, successive regions R¯ j ’s, j = k, k + 1, . . ., k +  − 1, to be satisfied that gˆ (R¯ j ) ≤ ε. At this situation, the repartition interval is defined as [gk−2 , gk+−1 ] which is covered by ( + 1) CMACs. Since there are  interior points in the repartition interval [gk−2 , gk+−1 ], repartitioning that interval can be simply implemented by linearly spacing one or two more interior points between the knots gk−2 and gk+−1 . That is to say, the repartition interval [gk−2 , gk+−1 ] becomes covered by ( + 2) or ( + 3) CMACs. Note that if the outmost interpolation region R¯ 1 (R¯ M+1 ) satisfies the evaluation criterion but its neighboring region R¯ 2 (R¯ M ) does not, this is a special case of  = 1. The repartition of this special case can be done by equally divide the interval [g0 , g1 ] or [gM−1 , gM ] into two or more parts. The algorithm for the CMAC growth process is presented below. Algorithm 2.

CMAC growth algorithm.

Step 1. Use (18) to find all network outputs. Step 2. Compute the relational grade for each interpolation region by (23). Step 3. Determine all possible repartition intervals satisfied the evaluation criterion for CMAC growth. Step 4. Quantize each repartition interval by linearly spacing one or two more interior points. Analogous to the state growth process, the CMAC growth process will stop when a specified performance measure or a pre-specified maximum number of CMACs (or epochs) is reached. However, this stop condition cannot involve in Algorithm 2. Step 4 causes a repartition interval to cover one or two more CMACs. After repartitioning, every CMAC associated with that repartition interval can be viewed as an untrained CMAC. Hence the state growth process must be applied to those CMACs again to adaptively quantize the input space of each CMAC and obtain the corresponding memory contents. The algorithm for the overall grey adaptive growing process is presented below. Algorithm 3.

Grey adaptive growing algorithm.

Step 1. Start with a network composed of a small number of 1D CMACs. Step 2. Uniformly quantize the input space of each CMAC into several states. Step 3. Determine whether the stopping criterion of the CMAC growth process is fulfilled or not. If fulfill, terminate the process; otherwise, go to Step 4. Step 4. Perform state growth algorithm. Step 5. Perform CMAC growth algorithm and then return to Step 2. 4. Simulation results In this section, the proposed GAG-CMAC network is applied to two function approximation problems to demonstrate its performance. All programs coded by Matlab version R14 were executed by a personal computer with Intel® CoreTM 2 Quad CPU Q8300 at 2.50-GHz processor and 2.75-GB RAM. 4.1. Example 1 Consider a GAG-CMAC network trained to generate the target function f(x1 , x2 ) = sinc(0.5 x1 )·sinc(0.5 x2 ), where (x1 , x2 ) ∈ [−1.2, 1.2] × [−1.2, 1.2]. The training set contains 441 (212 ) input pairs (x1 , x2 )’s which are uniformly distributed in the input space. In this example, each state is distributively stored in three memory elements, i.e., Ne = 3. Initially, the network is constructed by two 1D CMACs and the input space for each 1D CMAC is quantized into two states as given in the top left of Fig. 8. Besides, the repartition thresholds for both the state growth stage and the CMAC growth stage are set to be 0.9, i.e.,  = ε = 0.9, where the distinguishing coefficients  and are with the value of 1.0. For each 1D CMAC, the pre-specified maximum number of learning epochs for the state growth process is 4. Fig. 8 also depicts the quantization results for some epochs, where the number in each box indicates the index of this state for a specific 1D CMAC. The corresponding network outputs are shown in Fig. 9. Table 1 lists the detail numerical results for each epoch. Generally speaking, the RMSE of the learning result is gradually decreased as the number of CMACs is gradually increased. Since the target function is symmetric to the x1 -axis, the quantization result in each of those three epochs is also symmetric to x1 -axis. The similar manner also occurs in the x2 -axis. That is to say, the proposed approach could adaptively quantize the input space. Fig. 9 also reveals that, without using B-Spline or Gaussian function as the basis function in the network, the linear interpolation node could smooth the network output (see also in the next example). To verify the generalization ability of the proposed GAG-CMAC network, 1681 (412 ) input pairs which also uniformly distributed in the input space are selected as the testing set. Note that only 441 (about 26.2%) testing patterns have been trained. The RMSE of the testing result is 0.0367, which is slightly larger than that of the training result, i.e., 0.0359. Table 1 Numerical results of Example 1. Epoch

Number of CMACs

Number of states

Memory requirement

RMSE

1 2 3 4 5 6 7 8 9

2 3 4 5 6 7 8 9 12

24 39 64 40 44 44 56 56 76

28 45 72 50 56 58 72 74 100

0.2133 0.0813 0.0830 0.0723 0.0510 0.0527 0.0482 0.0412 0.0359

M.-F. Yeh, M.-S. Leu / Applied Soft Computing 11 (2011) 5400–5410

5407

Fig. 8. Quantization results in Example 1.

Table 2 compares the results of GAG-CMAC network with other models, in which “1 − N CMAC” represents that the number of nodes in the root and leaf layers for MS CMAC are 1 and N, respectively, “N1 × N2 CMAC” represents that the quantization numbers

of the x1 - and x2 -axes for Albus’ or Gaussian CMAC are N1 and N2 , respectively, and “SO-CMAC” represents the self-organizing CMAC proposed by Lin and Chen [16]. All of CMACs are trained with the learning rate  of 0.1. Except the SO-CMAC, the generalization size

Fig. 9. Network output for each epoch in Example 1.

5408

M.-F. Yeh, M.-S. Leu / Applied Soft Computing 11 (2011) 5400–5410

Table 2 Comparison of GAG-CMAC with other CMACs in Example 1. Model

GAG-CMAC MS CMAC 1–12 CMAC 1–16 CMAC Albus’ CMAC 12 × 12 CMAC 15 × 15 CMAC 16 × 16 CMAC 18 × 18 CMAC 21 × 21 CMAC Gaussian CMAC 8 × 8 CMAC 9 × 9 CMAC 12 × 12 CMAC 15 × 15 CMAC SO-CMAC

Number of states

Memory requirement

RMSE

Computational time (s)

Training

Testing

76

100 × 1

0.0359

0.0367

0.3750

144 256

182 × 1 306 × 1

0.0451 0.0368

0.0472 0.0406

0.4290 0.5090

144 225 256 324 441

66 × 1 97 × 1 108 × 1 134 × 1 177 × 1

0.0648 0.0480 0.0434 0.0220 0.0133

0.0661 0.0497 0.0465 0.0462 0.0438

0.1250 0.1250 0.1250 0.1260 0.1260

64 81 144 225 48

34 × 5 41 × 5 66 × 5 97 × 5 48 × 5

0.0316 0.0274 0.0223 0.0196 0.0463

0.0346 0.0377 0.0236 0.0260 0.0451

0.2340 0.2500 0.2500 0.2500 0.4220

Ne for each CMAC is set as 3. The learning performance of each model is measuring using RMSE and the computational time. The memory requirement of each model is also given in the same table, where “M1 × M2 ” represents the number of memory units and the number of memory elements in a memory unit are M1 and M2 , respectively. Note that a memory unit involves one and only one memory element (M2 = 1) for the proposed network and Albus’ CMACs, but 5 memory elements (M2 = 5) for Gaussian CMACs and SO-CMAC. The network structures of 1–8 MS CMAC and GAG-CMAC are similar, but the memory requirement of the former is larger than that of the latter. Although the state number of 1–13 MS CMAC is about triple of that of GAG-CMAC, the learning result of the former is still poorer than that of the latter. The main reason why the learning performance of the proposed network is better than that of those two models is that each 1D CMAC in the GAG-CMAC network could individually and adaptively quantize the corresponding input space, but the MS CMAC networks can not. As for Albus’ CMACs, the learning error is gradually reduced as the number of states is increased. The 16 × 16 CMAC has 108 memory elements which is slightly greater than the memory requirement of the proposed network, but its learning performance remains worse than that of GAG-CMAC network. While the input space is uniformly quantized into more than 324 (182 ) states, the corresponding 18 × 18 CMAC can outperform the proposed network in the learning result. Since each training instance is corresponding to one and only one state in the 21 × 21 CMAC, this manner could effectively reduce the learning interference during the learning process. Hence, the 21 × 21 CMAC can achieve the best training result. Even so, its generalization ability still remains poorer than the proposed network’s. As far as Gaussian CMACs are concerned, each of them has a better learning accuracy than GAG-CMAC, but only the 9 × 9 Gaussian CMAC is slightly poorer than GAG-CMAC in the generalization ability. Among them, the one with the smallest memory requirement is the 8 × 8 Gaussian CMAC which requires the amount of 170 (34 × 5) memory elements. Therefore, the memory requirement of any of Gaussian CMACs is larger than that of GAG-CMAC. As for the SO-CMAC, the initial number of layers is 2, the threshold value of generating a new layer is set as 0.25, and the threshold value of deleting an existing layer is 0.125. Once the structure learning process is completed, the final self-organizing structure is 48 layers. Each layer is associated with one and only one hypercube. Thus the memory requirement is 240 (48 × 5) which is very larger than that of the GAG-CMAC. Even so, the proposed network still outperforms the SO-CMAC in the learning accuracy and the generalization ability.

Among five kinds of CMAC models, the MS CMAC model takes the longest computational time to achieve the convergent state. The proposed GAG-CMAC attains the third fastest in the computational time. The main reason why Albus’ and Gaussian CMAC models require less computational time than the proposed network is that those CMACs are directly trained under some specific structures and do not take any structure learning process into consideration. While the GAG-CMAC is directly trained under the final quantization result given in Fig. 8, the corresponding computational time is only 0.0620 s. As can be seen, it is smaller than any computational time given in Table 2. To sum up, even if the target function is unknown in advance, the GAG-CMAC network not only has the adaptive quantization ability, but also can achieve a good learning accuracy with less memory requirement. Besides, the proposed network also performs the second best generalization ability among five kinds of the considered models. 4.2. Example 2 Let the target function be f(x1 , x2 ) = 2.5exp(−2x1 − 0.5x2 ) sinc( x1 )·sinc( x2 ), where (x1 , x2 ) ∈ [0.0,2.0] × [0.0,2.0]. Analogous to Example 1, the network initially is constructed by only two 1D CMACs with each corresponding space being equally quantized into two states as shown in the bottom left of Fig. 10. In this example, the pre-specified maximum number of learning epochs for the state growth process of each 1D CMAC is set as 4. The repartition thresholds for both the state growth stage and the CMAC growth stage are set to be 0.88. Except those parameters, the selection of other parameters such as Ne ,  and is the same as Example 1. While the network is trained by 441 (212 ) training instances also uniformly distributed in the input space, the learning result and the corresponding quantization of the input space at the end of the 7th epoch are depicted in the right column of Fig. 10. Since the target function in the region of [1.0,2.0] × [0.0,2.0] is very close to a flat surface, the proposed approach actually quantizes that region into a small amount of states by use of three 1D CMACs. The remaining region is partitioned into 55 states by use of other five CMACs. In this example, the testing set also contains 1681 (412 ) instances. Table 3 compares the results of GAG-CMAC network with other CMAC models. The parameter settings of all comparison models are the same as Example 1. With less memory requirement, the GAG-CMAC network outperforms two MS CMACs, the SO-CMAC network and four of five Albus’ CMACs in the training and testing accuracies and the learning speed. In addition, the proposed network is the second fastest among five kinds of CMAC models.

M.-F. Yeh, M.-S. Leu / Applied Soft Computing 11 (2011) 5400–5410

5409

Fig. 10. Simulation results of Example 2.

Although all of Gaussian CMACs surpass the GAG-CMAC network in the training accuracy, only two of them perform better testing accuracy than the proposed network. However they require much more memory elements to achieve such a learning performance. Besides, all of Gaussian CMACs also take more computational time than the proposed network. 4.3. Discussions Except the generalization parameter Ne and the repartition thresholds for the state growth stage and the CMAC growth stage ( and ε), the learning performance of the proposed GAG-CMAC is heavily depended on the initial quantization of the input space such as how many CMACs the network is constructed by and how

many states the input space of each CMAC is quantized into. In this study, the initial quantization for each example is set as 2 × 2 states. Such a simple initial quantization is used to examine whether the proposed grey adaptive growing mechanism has the adaptive quantization ability or not. The fact has been verified in the above two examples. The effects on the learning performance of different initial quantization are discussed as follows. If the initial quantization of the input space given in Example 1 becomes 5 × 7 states (i.e., the network is constructed by five CMACs and the input space for each CMAC is uniformly quantized into seven states), the corresponding numerical results are listed in Table 4. As can be seen, the RMSE of the training result is reduced from 0.0359 to 0.0179, while the RMSE of the testing result is from 0.0367 to 0.0181. In other words, the learning performance can be

Table 3 Comparison of GAG-CMAC with other CMACs in Example 2. Model

GAG-CMAC MS CMAC 1–8 CMAC 1–13 CMAC Albus’ CMAC 12 × 12 CMAC 13 × 13 CMAC 15 × 15 CMAC 18 × 18 CMAC 21 × 21 CMAC Gaussian CMAC 8 × 8 CMAC 9 × 9 CMAC 12 × 12 CMAC 15 × 15 CMAC SO-CMAC

Number of states

Memory requirement

RMSE

Computational time (s)

Training

Testing

77 × 1

0.0431

0.0363

0.1880

64 169

90 × 1 210 × 1

0.0618 0.0501

0.0602 0.0473

0.2040 0.2380

144 169 225 324 441

66 × 1 75 × 1 97 × 1 134 × 1 177 × 1

0.0730 0.0704 0.0636 0.0596 0.0166

0.0712 0.0681 0.0544 0.0512 0.0441

0.1440 0.1440 0.1440 0.1450 0.1450

64 81 144 225 54

34 × 5 41 × 5 66 × 5 97 × 5 54 × 5

0.0367 0.0410 0.0319 0.0225 0.0478

0.0371 0.0381 0.0353 0.0335 0.0458

0.2350 0.2350 0.2500 0.2500 0.4850

61

5410

M.-F. Yeh, M.-S. Leu / Applied Soft Computing 11 (2011) 5400–5410

Table 4 Simulation results of GAG-CMAC with different initializations. Initial quantization

Example 1 2 × 2 states 5 × 7 states Example 2 2 × 2 states 7 × 3 states

Number of states

76 154 61 78

Memory requirement

RMSE

Computational time (s)

Training

Testing

100 × 1 188 × 1

0.0359 0.0179

0.0367 0.0181

0.3750 0.5310

77 × 1 96 × 1

0.0431 0.0385

0.0363 0.0344

0.1880 0.1570

improved by a more complex quantization in the initialization. See also in the following case. Besides, except that the 21 × 21 Albus’ CMAC outperforms the 5 × 7 GAG-CMAC in the training accuracy, the 5 × 7 GAG-CMAC can attain the best performance in the training and testing accuracies among all of the CMACs given in Table 2. Table 4 also gives the results for Example 2 with the initial quantization of 7 × 3 states. As compared with Table 3, we can see that the 21 × 21 Albus’ CMAC and three of four Gaussian CMACs surpass the 7 × 3 GAG-CMAC in the training accuracy, but only the 15 × 15 Gaussian CMAC outperforms the 7 × 3 GAG-CMAC in the testing accuracy. Other CMACs are still poor than the 7 × 3 GAG-CMAC in the training and testing accuracies. 5. Conclusions This study developed a GAG-CMAC network which is constructed by several CMACs as a two-level tree structure. In the proposed network, not only the number of states for each CMAC but also the number of CMACs is gradually increased during the adaptive growing process. Without requiring the knowledge of the target function in advance and with the help of the proposed grey adaptive growing mechanism, the input space can be adaptively quantized during the learning process. In addition, the grey adaptive growing mechanism and the interpolation node enable the proposed GAG-CMAC network to achieve a better learning performance and a good generalization ability with less memory requirement. Acknowledgments This work was supported by the National Science Council, Taiwan, Republic of China, under Grants NSC 97-2221-E-262-009 and NSC 98-2221-E-262-004.

References [1] J.S. Albus, A new approach to manipulator control: the cerebellar model articulation controller (CMAC), J. Dyn. Syst. Meas. Contr. Trans. ASME 97 (3) (1975) 220–227. [2] J.S. Albus, Data storage in the cerebellar model articulation controller (CMAC), J. Dyn. Syst. Meas. Contr. Trans. ASME 97 (3) (1975) 228–233. [3] F.C. Chen, C.H. Chang, Practical stability issues in CMAC neural network control system, IEEE Trans. Contr. Syst. Technol. 4 (1996) 86–91. [4] S.F. Su, T. Tao, T.H. Hung, Credit assigned CMAC and its application to online learning robust controllers, IEEE Trans. Syst. Man Cybern. B 33 (2) (2003) 202–213. [5] M.F. Yeh, Single-input CMAC control system, Neurocomputing 70 (2007) 2638–2644. [6] C.H. Tsai, M.F. Yeh, Application of CMAC neural network to the control of induction motor drives, Appl. Soft Comput. (2008), doi:10.1016/j.asoc.2009.05.001. [7] C.T. Chiang, C.S. Lin, CMAC with general basis functions, Neural Netw. 9 (7) (1996) 1199–1211. [8] H.M. Lee, C.M. Chen, Y.F. Lu, A self-organizing HCMAC neural-network classifier, IEEE Trans. Neural Netw. 14 (1) (2003) 15–27. [9] C.S. Lin, C.K. Li, A new neural structure composed of small CMACs, in: Proc. 1996 Int. Joint Conf. Neural Netw., vol. 3, Washington, DC, 1996, pp. 1777–1783. [10] S.L. Hung, J.C. Jan, MS CMAC neural-network learning model in structural engineering, J. Comput. Civil Eng. ASCE 13 (1) (1999) 1–11. [11] J.C. Jan, S.L. Hung, High-order MS CMAC neural network, IEEE Trans. Neural Netw. 12 (3) (2001) 598–603. [12] J.C. Jan, C.M. Chen, L.H. Hsiao, Inverse training scheme for MS CMAC neural network to handle random training data, Neurocomputing 70 (2006) 502–512. [13] C.Y. Lee, C.J. Lin, H.J. Chen, A self-constructing fuzzy CMAC model and its applications, Inform. Sci. 151 (2007) 264–280. [14] C.J. Lin, J.H. Lee, C.Y. Lee, A novel hybrid learning algorithm for parametric fuzzy CMAC networks and its classification applications, Expert Syst. Appl. 35 (2008) 1711–1720. [15] K.S. Hwang, C.S. Lin, Smoothing trajectory tracking of three-link robot: a selforganizing CMAC approach, IEEE Trans. Syst. Man Cybern. B Cybern. 28 (5) (1998) 680–692. [16] C.M. Lin, T.Y. Chen, Self-organizing CMAC control for a class of MIMO uncertain nonlinear systems, IEEE Trans. Neural Netw. 2 (9) (2009) 1377–1384. [17] J.L. Deng, Introduction to grey system theory, J. Grey Syst. 1 (1989) 1–24. [18] G. Horváth, T. Szabó, Kernel CMAC with improved capability, IEEE Trans. Syst. Man Cybern. B 37 (1) (2007) 124–138. [19] D.E. Thompson, S. Kwon, Neighborhood sequential and random training techniques for CMAC, IEEE Trans. Neural Netw. 6 (1) (1995) 196–202.