Type Reduction of Fls-t2

8/18/2019 Type Reduction of Fls-t2

1/24

IEEE TRANSACTIONS ON FUZZY SYSTEMS, VOL. 18, NO. 4, AUGUST 2010 637

Toward General Type-2 Fuzzy Logic SystemsBased on zSlices

Christian Wagner , Member, IEEE , and Hani Hagras , Senior Member, IEEE

Abstract—Higher order fuzzy logic systems (FLSs), such as in-terval type-2 FLSs, have been shown to be very well suited to dealwith the high levels of uncertainties present in the majority of real-world applications. General type-2 FLSs are expected to fur-ther extend this capability. However, the immense computationalcomplexities associated with general type-2 FLSs have, until re-cently, prevented their application to real-world control problems.This paper aims to address this problem by the introduction of acomplete representation framework, which is referred to as zSlices-based general type-2 fuzzy systems. The proposed approach willlead to a significant reduction in both the complexity and the com-putational requirements for general type-2 FLSs, while it offersthe capability to represent complex general type-2 fuzzy sets. As

a proof-of-concept application, we have implemented a zSlices-based general type-2 FLS for a two-wheeled mobile robot, whichoperates in a real-world outdoor environment. We have evaluatedthe computational performance of the zSlices-based general type-2 FLS, which is suitable for multiprocessor execution. Finally, wehavecompared the performance of the zSlices-based general type-2FLS against type-1 and interval type-2 FLSs, and a series of resultsis presented which is related to the different levels of uncertaintyhandled by the different types of FLSs.

Index Terms—General type-2 fuzzy logic systems (FLSs), type-2FLSs, zSlices.

I. INTRODUCTION

FUZZY logic is credited with being an adequate method-

ology for designing robust systems that are able to de-

liver a satisfactory performance in the face of uncertainty and

imprecision. Hence, the Fuzzy Logic System (FLS) has be-

come established as an adequate technique for a variety of

applications.

While type-1 fuzzy logic has been the most popular form of

fuzzy logic, recent years have shown a significant increase in

research toward more complex forms of fuzzy logic, in particu-

lar, interval type-2 fuzzy logic [1]–[3], and, even more recently,

general type-2 fuzzy logic [4]–[11]. This transition from type-1to more complex forms of fuzzy logic hasbeen largely motivated

by the realization that type-1 fuzzy sets only offer limited scope

Manuscript received February 24, 2009; revised November 30, 2009 andFebruary 8, 2010; accepted February 10, 2010. Date of publication March 11,2010; date of current version August 6, 2010.

C. Wagner is with the School of Computer Science and ElectronicEngineering, University of Essex, Colchester CO4 3SQ, U.K. (e-mail:[email protected]).

H. Hagras is with the School of Computer Science and Electronic Engi-neering, Fuzzy Systems Research Group, Computational Intelligence Centre,University of Essex, Colchester CO4 3SQ, U.K. (e-mail: [email protected]).

Color versions of one or more of the figures in this paper are available onlineat http://ieeexplore.ieee.org.

Digital Object Identifier 10.1109/TFUZZ.2010.2045386

Fig. 1. View of the secondary MFs (third dimensions) of (a) type-1 fuzzy set,(b) interval type-2 fuzzy set, and (c) general type-2 fuzzy set.

for modeling uncertainty and, as such, cannot handle the high

levels of uncertainty, which are usually present in real-world

applications [1]–[3].

Type-2 fuzzy logic allows for better modeling of uncertainty

as type-2 fuzzy sets encompass a Footprint Of Uncertainty

(FOU) which, associated with its third dimension, gives more

degrees of freedom to type-2 fuzzy sets in comparison to type-1

fuzzy sets [2], [3].

Several publications have shown that interval type-2 FLSs

can outperform their type-1 FLSs counterparts in a variety of

applications [1], [12]–[19]. This has been largely attributed to

the ability of interval type-2 sets to better model the faced un-certainty and the fact that an interval type-2 set can be seen to

possess an uncountable numberof embedded type-1sets [1]–[3].

General type-2 FLSs have only recently been investigated in

more detail [4]–[11], [16] as the high complexity associated

with their design and their computational requirements made

them appear unsuitable for real-world use. Given the experi-

ence with interval type-2 FLSs, it is expected that the general

type-2 fuzzy sets employed within the general type-2 FLS will

have the ability to model uncertainty more accurately than in-

terval type-2 sets, which, in turn, will result in the potential for

a superior control performance in comparison to type-1 and in-

terval type-2 FLSs. This potential is shown in concept in Fig. 1,

which shows the secondary Membership Functions (MFs) (thirddimension) of type-1 fuzzy sets [see Fig. 1(a)], interval type-2

fuzzy sets [see Fig. 1(b)], and general type-2 fuzzy sets [see

Fig. 1(c)]. As shown in Fig. 1(a), the secondary MF in type-1

fuzzy sets has only one value in its domain [a in Fig. 1(a)]

corresponding to the primary-membership value at which the

secondary grade equals 1. Hence, in type-1 fuzzy sets, for each

x value, there is no uncertainty associated with the primarymembership value [3]. In interval type-2 fuzzy sets, as shown in

Fig. 1(b), there is maximum uncertainty represented in the sec-

ondary MF, as the primary membership is taking values within

the interval [a, b], where each point in this interval is having an

associated secondary membership of 1. In general type-2 fuzzy

1063-6706/$26.00 © 2010 IEEE


2/24

638 IEEE TRANSACTIONS ON FUZZY SYSTEMS, VOL. 18, NO. 4, AUGUST 2010

sets, as shown in Fig. 1(c), the uncertainty (represented in the

secondary MF) can be modeled with any degree between type-1

and interval type-2 fuzzy sets, for example, by the triangular

secondary MF shown in Fig. 1(c). Hence, general type-2 fuzzy

sets can model the uncertainty in the third dimension precisely,

from nearly no uncertainty (i.e., type-1) to maximum (i.e., inter-

val type-2, where the uncertainty is equally spread in the third

dimension).

Several efforts have been made in order to limit the complex-

ity of general type-2 fuzzy logic; in particular, new forms of

representations have been devised in order to enable the use of

general type-2 FLSs in real-world applications. Coupland and

John [4] have presented a geometric representation of general

type-2 sets, and, recently, other forms of representation have

been introduced, where Mendel and Liu [5], [6] have put for-

ward a representation based on alpha planes, while Wagner and

Hagras [9] have introduced the zSlices-based representation.

Furthermore, several other advances have been made in trying

to reduce the complexity associated with general type-2 fuzzy

systems [2], [7], [8], [11]. Coupland etal. [16] have investigatedthe potential of general type-2 FLSs in robot control.

In this paper, we have given an in-depth description of the

zSlices-based representation, which enables the representation

of and computation with general type-2 fuzzy sets and their

associated third dimensions at a levelof precision and associated

computational overhead, which can be chosen as required by the

respective application.

We will present how a complete zSlices-based general type-2

FLS can be implemented as well as analyze the performance of

a zSlices-based general type-2 FLS in computational terms as

well as in comparison to interval type-2 and type-1 FLSs.

Section II will recapitulate the concepts and notations of stan-dard general type-2 fuzzy sets, while Section III will focus on the

concepts and notations of zSlices-based general-type fuzzy sets.

Section IV will present the details of standard general type-2

FLSs followed by specific details of zSlices-based general

type-2 FLSs in Section V. The experiments and results are de-

scribed in Section VI. Finally, the conclusions are presented in

Section VII. The proofs of the novel theorems presented in this

paper are included in the Appendixes.

II. GENERAL TYPE-2 FUZZY SETS

General type-2fuzzysets [20] arean extension of type-1fuzzy

sets. As shown in [3], while a type-1 fuzzy set F is characterizedby a type-1 MF µF (x), where x ∈ X and µF (x) ∈ [0, 1], ageneral type-2 set F̃ is characterized by a general type-2 MFµ̃F (x, u), where x ∈ X and u ∈ J x ⊆ [0, 1], i.e.,

F̃ = {((x, u) , µF̃ (x, u)) |∀x ∈ X ∀u ∈ J x ⊆ [0, 1] } (1)

in which µF̃ (x, u) ∈ [0, 1]. F̃ can also be expressed as follows

[3]:

F̃ =

x∈X

u ∈J x

µF̃ (x, u)/(x, u), J x ⊆ [0, 1] (2)

where

denotes unionover all admissiblex and u. An example

of a general type-2 fuzzy set is depicted in Fig. 2(a) and (b). J x

Fig. 2. (a) Side view of a general type-2 fuzzy set, indicating three zLevels

on the third dimension. (b) Tilted rear/below view of the same set, indicatingthe position of the three zSlices (dashed lines). (c) Side view of the zSlicesversion of the set in (a), with I = 3. (d) Tilted rear/below view of the sameset, showing the zSlices. Note: To improve the accessibility of the complex 3-Dnature of general type-2 fuzzy set, we are referring to the three dimensions in

the traditional mathematical notation of x, y, and z. These designations are

equivalent to the respective traditional designations in the fuzzy logic field of x,

u, and µ(x, u) (or f x (u)).

is called the primary membership of x in F̃ . At each value of xsay x = x, the two-dimensional (2-D) plane, whose axes are uand µF̃ (x

, u), is called a vertical slice of F̃ [2]. A secondary

MF is a vertical slice of F̃ . It is µF̃ (x = x, u), for x ∈ X and

∀u ∈ J x ⊆ [0, 1], [2], i.e.,

µF̃ (x = x, u) ≡ µF̃ (x

)

=

u ∈J x

f x (u)/u J x ⊆ [0, 1] (3)

in which 0 ≤ f x (u) ≤ 1. Because ∀x ∈ X , the prime notation

on µF̃ (x) is dropped, and µF̃ (x) is referred to as a secondary

MF [2]; it is a type-1 fuzzy set, which is also referred to as a

secondary set [2]. If ∀x ∈ X , the secondary MF is an intervaltype-1 set, where f x (u) = 1, the type-2 set F̃ is referred to asan interval type-2 fuzzy set.

Besides the vertical slice representation mentioned earlier, a

general type-2 fuzzy set can also be represented as a series of

wavy slices, where, for discrete universes of discourse X andU , Mendel and John [2] have shown that a type-2 fuzzy set F̃ can be represented as follows:

F̃ =n

j = 1

F̃ je (4)

where F̃ je is an embedded type-2 fuzzy set, which can be writtenas follows:

F̃ je =N

d=1

[f xd (u jd )/u

jd ]/xd (5)

where u j

d ∈ J xd ⊆ U = [0, 1].


3/24

WAGNER AND HAGRAS: TOWARD GENERAL TYPE-2 FUZZY LOGIC SYSTEMS BASED ON zSLICES 639

Fig. 3. (a) Front view of a general type-2 set F̃ . (b) Third dimension at x of a zSlices-based type-2 fuzzy set with I = 4.

F̃ je has N elements, as it contains exactly one elementfrom J x1 , J x2 , . . . , J xN , namely, u

j1 , u

j2 , . . . , u

jN , each with

its associated secondary grade, namely, f x1 (u j1 ), f x2 (u j2 ), . . . ,f xN (u

jN ) [3].

F̃ je is embedded in F̃ , and there is a total of

n = N

d=1 M d embedded sets F̃ je [2], where M d is the dis-

cretization level of u jd at each xd [2], [3].

III. ZSLICES-BASED GENERAL TYPE-2 FUZZY SETS

A. Introduction to zSlices

A zSlice is formed by slicing a general type-2 fuzzy set in the

third dimension (z) at level zi . This slicing action will result inan interval set in the third dimension with height zi . As such,a zSlice Z̃ i is equivalent to an interval type-2 fuzzy set with

the exception that its membership grade µZ̃ i (x, u ) in the thirddimension is not fixed to 1 but is equal to zi , where 0 ≤ zi ≤ 1.Thus, the zSlice Z̃ i can be written as follows:

Z̃ i =

x∈X

u i ∈J i x

zi /(x, ui ) (6)

where at each x value [as shown in Fig. 3(a)], zSlicing createsan interval set with height zi and domain J ix , which ranges fromli to ri , as shown in Fig. 3(b), 1 ≤ i ≤ I , where I is the numberof zSlices (excluding Z̃ 0 ) and zi = i/I .

Thus, (6) can be written as follows:

Z̃ i = x∈X u i ∈[li ,r i ] zi /(x, ui ). (7)

Additionally

Z̃ 0 =

x∈X

u ∈J x

0/(x, u) (8)

where Z̃ 0 is considered as a special case with z = 0. It should benoted that in the derivations of the zSlices-based general type-2

FLS, we will only consider the zSlices Z̃ i , where 1 ≤ i ≤ I aswe are going to see in Section V that Z̃ 0 does not contribute tothe crisp output of the zSlices-based type-2 FLS and, in fact,

can be omitted throughout the FLS with no effects.

A zSlice can also be expressed as follows:

Z̃ i = {((x, ui ) , zi ) |∀x ∈ X, ∀ui ∈ [li , ri ]} . (9)

B. zSlices-Based General Type-2 Fuzzy Sets

A general type-2 fuzzy set F̃ can be seen equivalent to thecollection of an infinite number of zSlices

F̃ = 0≤i≤I

Z̃ i I → ∞. (10)

In a discrete universe of discourse, (10) can be rewritten as

follows:

F̃ =I

i=0

Z̃ i . (11)

We will refer to the discrete version in (11) throughout the

paper. It should be noted that the summation signs in (11) and

(12) do not denote arithmetic addition, but they denote the union

set-theoretic operation [3]. We have employed the maximum

operation to represent the union; hence, whenever a u value isattached to more than one zi values, the maximum zi is chosenand attached to the given u value. Hence, the MF µF̃ (x

) at x of

the zSlices-based general type-2 fuzzy set F̃ shown in Fig. 3(b)can be expressed as follows:

µF̃ (x) =

I i=0

u i ∈[li ,r i ]

zi /ui

=

u i ∈J x

max(zi )/u, J x ⊆ [0, 1] (12)

where 0 ≤ i ≤ I . It is worth noting that at x, µF̃ (x) is a type-1

fuzzy set.Fig. 2 shows a 3-D diagram for a general type-2 fuzzy set

[shown in Fig. 2(a) and (b)] that is represented as a zSlices-

based general type-2 set [see Fig. 2(c) and (d)] with I = 3.The intersection and union operations implemented through the

meet and join operations on the zSlices-based general type-2

fuzzy sets are summarized next and have been described in

detail in [9].

In accordance with the theorems of the join and meet op-

erations for zSlices-based general type-2 fuzzy sets explained

in [9], the join operation between two zSlices-based general

type-2 fuzzy sets reduces to the computation of the join oper-

ation (which employs the maximum t-conorm) between each


4/24


Fig. 4. Structure of a general type-2 FLS.

corresponding zSlice in both sets and can be written as follows:

Ã B̃ ⇔ µÃ B̃

= µÃ (x) µB̃ (x)

=I

i= 0

k ∈[max(lA i ,l B i ),max(rA i ,r B i )]

zi /k ∀x ∈ X . (13)

The meet operation between two zSlices-based general type-2

fuzzy sets reduces to the computation of the meet operation

(which employs the minimum t-norm) between each corre-sponding zSlices in both sets and can be written as follows:

Ã B̃ ⇔ µÃB̃

= µÃ (x) µB̃ (x)

=

I i=0

k ∈[min(lA i ,l B i ),min(rA i ,r B i )]

zi /k ∀x ∈ X . (14)

Finally, it is worth noting that a zSlices-based fuzzy set Z̃ ,where I = 1 is a general type-2 fuzzy set with a zSlice Z̃ 0 atzLevel 0, which does not contribute to the fuzzy set (points with

a secondary membership of 0 are not actually part of the set) and

a zSlice Z̃ 1 at zLevel 1. As such, a zSlices-based general type-2fuzzy set with I = 1 is equivalent to a standard interval type-2fuzzy set, and consequently, standard interval type-2 operations

are applicable.

IV. GENERAL TYPE-2 FUZZY LOGIC SYSTEMS

A type-2 FLSconsistsof fivecomponents, which arefuzzifier,

rule base, inference engine, type reducer, and defuzzifier, as

shown in Fig. 4. A type-2 FLS operates on type-2 fuzzy sets,

which are used to represent the inputs and outputs of the FLS.

An FLS, which uses at least one general type-2 fuzzy set is

referred to as a general type-2 FLS [21].

It has previously been shown that interval type-2 FLSs canprovide better performance than type-1 FLSs with the same

number of rules, which has been attributed to the fact that in-

terval type-2 fuzzy sets can better handle the uncertainties and

can be seen to include a huge number of embedded type-1

fuzzy sets. By analogy, interval type-2 FLSs can be thought of

as collections of an uncountable number of embedded type-1

FLSs [1], [3].

As interval type-2 fuzzy sets distribute the uncertainty evenly

across the FOU, it is natural to expect an improvement in mod-

eling accuracy and, thus, performance when employing general

type-2 fuzzy sets, which allow for an uneven distribution in ap-

plications, where the uncertainty is not evenly distributed, and

we have information about this uneven distribution. The next

sections introduce the operation of the general type-2 FLS.

A. Fuzzifier

The fuzzifier maps crisp inputs into general type-2 fuzzy sets

to process within the FLS. In this paper, we will focus on the

type-2 singleton fuzzifier as it is fast to compute and, thus, suit-

able for the general type-2 FLS real-time operation. Singleton

fuzzification maps the crisp input into a fuzzy set, which has a

single point of nonzero membership. Hence, the singleton fuzzi-

fier maps the crisp input x p into a type-2 fuzzy singleton, whoseMF is µX̃ p (x p ) = 1/1 for x p = x

p , and µX̃ p (x p ) = 0 for all

x p = x

p , for all p = 1, . . . , P , where P is the number of FLSinputs.

B. Rule Base

The rule structure within general type-2 FLSs is the standard

Mamdani-type FLS rule structure employed in type-1 and in-

terval type-2 FLSs. Throughout the paper, we assume that all

antecedent and consequent sets in the rules are general type-2

fuzzy sets. However, this need not necessarily be the case, as

all the reported results will remain valid as long as just any of the antecedent and/or consequent sets of the FLS is a general

type-2 fuzzy set.

As such, a rule Rs from a general type-2 FLS can be writtenas follows:

Rs : IF x1 is F̃ 1 AND . . . AND x p is F̃ P

THEN g1 is G̃1 , . . . , gQ is G̃Q , s ∈ {1, . . . , S } (15)

where P is the number of FLS inputs, Q is the number of FLSoutputs, and S is the number of rules in the rule base.

C. Fuzzy Inference Engine

During the inference process, a series of operations are exe-

cuted as follows [3].

1) The rules’ firing strengths are determined, where the firing

set F S (x) for each rule S (which is a type-1 fuzzy set)for a singleton type-2 FLS is computed as follows [3]:

F S (x) = p p=1 µF̃ S p (x

p ) (16)

where denotes the type-2 meet operation, which ac-counts for the intersection in type-2 fuzzy systems. In

this paper, we will use the meet under minimum t-norm.

µF̃ s p (x

p ) represents the MF of x

p on the antecedent type-2


5/24


TABLE IINDICATION OF THE NUMBER OF WAVY SLICES INVOLVED IN STANDARD-TYPE REDUCTION AND THE ASSOCIATED COMPUTATIONAL (MEMORY) REQUIREMENTS

fuzzy set F̃ s p . As shown in (3), µF̃ s p (x

p ) is a type-1 fuzzy

set, which is a vertical slice at x p of F̃ s

p .

2) In order to apply the firing strength F s (x) to the re-spective consequent set G̃S , we compute the cylindricalextension [7] F̃ S C of F

s (x), which results in the followingset:

F̃ S C = F s (x) ∀g ∈ G. (17)

As such, the cylindrical extension of F s (x) can be seen

as a copy of F s

(x

) for every g ∈ G.3) In a Multiple-Input–Single-Output (MISO) FLS, the in-ferred output µB̃ S (g) of each rule s is computed as fol-lows [7]:

µB̃ s (g) = µG̃ s (g)

P p= 1 µF̃ s p (x

p )

= µG̃ s (g) µF̃ sC ∀g ∈ G (18)

where µG̃ s is the type-2 fuzzy MF that represents the sthrule consequent. The cylindrical extension facilitates the

process to find the meet (under minimum t-norm) of therule firing strength with the membership grade of every

point of the consequent set [7].

4) The outputs of the fired rules (M ) are combined using the join operation (which accounts for the union operation in

type-2 fuzzy systems) to produce the overall output set,

whose MF is µB̃ (g) ∀g ∈ G, which can be written asfollows [3]:

µB̃ (g) = M s= 1 µB̃ S (g) ∀g ∈ G. (19)

In a Multiple-Input–Multiple-Output (MIMO) system,

steps 2, 3, and 4 are repeated for every output set individually.

The intersection operation for general type-2 fuzzy sets can

be computed by discretizing the respective sets into vertical

slices and performing the meet operation as described in [10].

Similarly, the union operation for general type-2 fuzzy sets can

be computed by discretizing the respective sets into vertical

slices and performing the join operation.

D. Type Reduction

In order to obtain crisp outputs from the general type-2 FLS

output, the collective output set [the MF of which is µB̃ (g),shown in (19)] that was generated from the inference engine is

processed in two stages. Initially, it is type-reduced to a type-1

set, which is then defuzzified to a crisp output.

The standard type-reduction method for general type-2 setsis the centroid type reduction [3], which is based on comput-

ing the centroid of every wavy slice within the output set [2].

This is usually not possible in real-time control as it leads to

exponential growth in computational requirements as the num-

ber of discretizations increases along the x- and y-axes. Table Iindicates the very large numbers of wavy slices and resultant

memory requirements (if all the wavy slices were to be held

in memory at any one time) as one indicator of the computa-

tional requirements. The computational time associated with the

computation of the centroids is dependent on the computational

resources available, but with today’s computers, the computa-

tion of the standard centroid type reduction is not an option for

control applications, even for relatively low levels of discretiza-

tion, as shown in Table I.

An example comparing standard centroid type reduction

to zSlices-based centroid type reduction can be found in

Appendix I. Other methods have been introduced, which aim

to circumvent the computational bottleneck of standard centroid

type reduction, such as vertical slice-centroid-type reduction [7]

and the random sampling method [11].

E. Defuzzification

Defuzzification processes the type-1 fuzzy output set pro-

duced during the type-reduction process. A large variety of


6/24


different defuzzification methods have been presented, includ-

ing centroid defuzzification [3].

F. Implementation Details

The implementation and application of a general type-2 FLS

presents significant challenges because of the aforementioned

complexity and computational requirements. While there aresome areas that offer potential for parallel execution and, thus,

performance increase such as the evaluation of individual rules

in parallel as well as the computation of the centroids of in-

dividual wavy slices during type reduction, the general type-2

FLS in its standard form is not suitable for real-world control

applications today. Hence, as mentioned earlier, new forms of

representations have been devised in order to enable the use

of general type-2 FLSs in real-world applications, such as the

geometric representation of general type-2 sets [4] andthe quasi-

type-2 fuzzy systems, which are based on alpha planes [5], [6].

Furthermore, several other advances have been made in trying

to reduce the complexity associated with general type-2 fuzzysets [2], [7], [8], [10]. However to date, the only real-world

application of a general type-2 FLS has been in the field of

experimental mobile robotics by Coupland et al. [16], who em-

ployed the geometric representation of general type-2 sets [4]

and have compared the control performance of interval type-2,

general type-2, and type-1 FLSs in [16].

V. ZSLICES-BASED GENERAL TYPE-2 FUZZY LOGIC SYSTEMS

A. Fuzzifier

In zSlices-based FLSs (zFLSs), the fuzzification step is iden-

tical to standard general type-2 FLSs (while employing zSlices-based general type-2 fuzzy sets). In this paper, we are using

singleton fuzzification. The singleton fuzzifier maps the crisp

input x p into a type-2 fuzzy singleton, whose MF is µX̃ p (x p ) =

1/1 for x p = x

p , and µX̃ p (x p ) = 0 for all x p = x

p , for all

p = 1, . . . , P , where P is the number of FLS inputs. The sin-gleton fuzzifier is commonly used in type-2 FLSs because of its

computational simplicity. The use of zSlices-based type-2 FLSs

significantly reduces the amount of computational resources

required, which makes the use of nonsingleton fuzzification

methods a realistic option for the future.

B. Rule BaseThe structure of the rules in zFLSs is identical to that in

standard general type-2 FLSs. The fuzzy sets employed in the

rules are zSlices-based general type-2 fuzzy sets, as described

in Section III-B. In this paper, we will solely focus on zFLSs,

where all the employed fuzzy sets are zSlices-based general

type-2 fuzzy sets. All the reported results will remain valid as

long as just any of the antecedent and/or consequent of the

FLS employ a zSlices-based general type-2 fuzzy set. In the

case, where some of the antecedent or consequent sets are not

zSlices-based, the respective general, interval type-2, and type-1

sets will be converted to zSlices-based sets, as indicated in

Section V-F.

C. Fuzzy Inference Engine

The inference engine within a zFLS is significantly different

to a standard general type-2 FLS, as it employs zSlices-based

general type-2 sets, which can be seen as a combination of a se-

ries of interval type-2 fuzzy sets with a specified third dimension

(i.e., zSlices) as shown in Section III and [9].

Consider a zFLS, which employs zSlices-based generaltype-2 fuzzy sets Z̃ with a number I of zSlices. As such, thesteps within the fuzzy inference engine will be as follows.

1) The firing set ZF s (x) for each rule s for a singleton zFLScan be considered similar to that of a standard general

type-2 FLS, as shown in (16)

ZF s (x) = P p=1 µZ̃ s p (x

p ) (20)

where Z̃ s p refers to the zSlices-based general type-2 fuzzyset to represent the antecedent p of rule s, and µZ̃ s p (x

p )

represents as such the membership value of the input x pto Z̃ s

p . As mentioned earlier, µ ˜

Z s

p

(x p

) is a vertical slice at

x p of Z̃ s p ; hence, µZ̃ s p (x

p ) is a type-1 fuzzy set, which is

zSlices-based and could be written according to (12). As

the zFLS is employing zSlices-based general type-2 sets,

and by taking the meet operation for zSlices [described in

(14)] into account, (20) can be computed as follows:

ZF s (x)

=I

i= 1

k ∈

mi n

l Z̃ s

1 i

,l Z̃ s2 i

,...,l Z̃ sP i

,m in

r Z̃ s

1 i

,r Z̃ s2 i

,...r Z̃ sP i

zi /k(21)

where l and r designate the left and right endpoints of therespective intervals of J ix of a given

Z̃ s p .As the firing strength for each zLevel is as such de-

termined separately, the inference process can be con-

cluded as zSlice-by-zSlice throughout the zFLS until all

the zLevels are recombined during the type-reduction

stage.

An example of the inference process is shown in Fig. 5

for a two-input zFLS (with three zSlices), where two in-

puts a and b are being applied to the zFLS. The zFLSexample shown in this section is based on the zFLS de-

scribed in Section VI for robot control, with the exceptionthat the example is shown for three zSlices instead of four

to facilitate the visualization. The simple rule base of the

zFLS is given in Table II.

In the example shown in Fig. 5, only rule number four

fires. Theprocess of determining its firing strength follows

(21) and the result for ZF 4 (x) is shown in Fig. 6(a).2) In order to apply the firing strength ZF s (x) to the respec-

tive consequent set µQ̃ sz (g), we compute the cylindrical

extension [7] ZF S C of Z F s (x), which results in the fol-lowing set:

ZF S C = Z F s (x) ∀g ∈ G. (22)


7/24


Fig. 5. Generation of vertical slices through the application of the inputs aand b to their respective input sets. (a) Input a resulting in a vertical slice of theset near . (b) Input b resulting in a vertical slice of the set far . (c) Visualization(on the y –z plane) of the vertical slice shown in (a). (d) Visualization (on they–z plane) of the vertical slice shown in (b).

TABLE IIRULE BASE OF THE ZFLS

As such, the cylindrical extension of Z F s (x) can beseen as a copy of ZF s (x) for every g ∈ G. The cylindri-

cal extensionZF 4C of the firing strength ZF 4 (x) , shownin Fig. 6(a), is shown in Fig. 6(b).

3) In an MISO zFLS, the inferred output µG̃ sz (g) of each

rule s can also be considered similar to that of a standard

Fig. 6. (a) Computation of the rule firing strength for rule 4. (b) Computingthe cylindrical extension of the rule’s firing strength.

general type-2 FLS, as shown in (18)

µQ̃ S z (g) = µG̃ S Z (g) ZF S C ∀g ∈ G (23)

where µG̃ sz (g) is the zSlices-based type-2 fuzzy MF thatrepresents the sth rule consequent. As zSlices-based gen-eral type-2 sets are employed and having taken the meet

operation for zSlices (described in (14) and [9]) into ac-

count, µQ̃ sz (g) in (23) can be computed as follows:

µQ̃ sz (g)

=

I

i= 1 k ∈

mi n

lµZ F S

C i

,l µG̃ s

z i

,m in

rµZ F S

C i

,r µG̃ s

z i

zi /k∀g ∈ G. (24)

The process of computation of the inferred output for the

aforementioned example is visually shown in Fig. 7(a),

where the consequent of rule 4 is the right linguistic label

represented by µG̃ 4z (g), which is also shown in Fig. 7(a).

The resultant inferred output (µQ̃ 4z (g)) is shown from thefront in Fig. 7(b) and from the rear in Fig. 7(c).

4) The outputs of the fired rules (M ), which were computed

using (23) and (24) are combined using the zSlices-based


8/24


Fig. 7. (a) Computing the rule’s inferred output by intersecting the cylindricalextension of its firing strength with the rule consequent set. (b) Inferred outputset of the rule from the front. (c) Inferred output set of the rule from the rear.

union operation, which is based on the join operation (de-

scribed in (13) and [9]), to produce the overall zSlices-

based output set, whose MF µQ̃ z (g) ∀g ∈ G, can be writ-ten as in (25), shown at the bottom of the page.

In the example given here, only one rule fires. Nevertheless,

the process of combination of the outputs of individual rules is

exemplified for the case that two rules fired, as shown in Fig. 8.

In an MIMO system, steps 2–4 are repeated for every output set

individually.

Fig. 8. Combination (union) of the output of two fired rules by computingthe union based on a vertical slice-by-slice computation of the join operation.(a) Resulting overall output set from the front. (b) Resulting overall output setfrom the rear. (c) Join operation at the vertical slice x = d .

D. Type Reduction

Type reduction for zSlices-based general type-2 sets also em-

ploys the nature of zSlices, which can be seen as standard inter-

val type-2 fuzzy sets with a specific zLevel zi ∈ [0, 1]. As typereduction relies on the principle of a centroid calculation on the

set in question, we first address the centroid calculation of a

µQ̃ z (g) = M s= 1 µQ̃ sz (g) =

I i= 1

k ∈

ma xM s = 1

m in

lµ

Z F S C i

,l µG̃ s

z i ,ma xM s = 1

m in

rµ

Z F S C i

,r µG̃ s

z i zi /k ∀g ∈ G. (25)


9/24


Fig. 9. (a)Type-reducedset of theinterval type-2FLS at i = 1 associated witha height of z1 = 0.33. (b) Type-reduced set of the interval type-2 FLS at i = 2associated with a height of z2 = 0.66. (c) Type reduced of the interval type-2FLS at i = 3 associated with a height of z3 = 1. (d) Overall type-reduced setof the FLS.

zSlices-based general type-2 fuzzy set in Theorem 1 next. The

results in Theorem 1 were first given in [6], although they are

stated and proved using the notation and terminology of alpha

planes. For completeness, the proof of this theorem is given in

Section A of Appendix I, using the terminology and notation of

zSlices, to be consistent with the rest of this paper.

Theorem 1: The centroid C ̃Z for a zSlices-based generaltype-2 fuzzy set Z̃ is equivalent to the combination of the cen-troids of its zSlices Z̃ i . The centroid of each individual zSlicecan be calculated in exactly the same fashion as the centroid for

interval type-2 fuzzy sets, while maintaining the zLevel of each

individual zSlice. As such, C Z̃ can be written as the combina-tion of the centroids of its zSlices C Z̃ i , each associated withtheir respective zLevel zi

C ̃Z =I

i= 1

zi /C Z̃ i . (26)

Here, C Z̃ i represents the centroid of the zSlices-based generaltype-2 fuzzy set formed by the zSlices Z̃ i . As C Z̃ i is bounded bytwo endpoints, we can write C Z̃ i = [clz i , cr zi ], where clz i andcr z i are the left and right endpoints of the interval, respectively.These endpoints are calculated using standard interval type-2

algorithms (like the iterative Karnik–Mendel (KM) procedure

[3]) applied to every zSlice Z̃ i .The proof of Theorem 1 can be found in Appendix I. The cen-

troid calculation process for the output set shown in Fig. 7(b)

and (c) is visualized as part of the center-of-sets (COS) type-

reduction process in Fig. 9. An example to compare the com-

putation of the standard centroid to that of the zSlices-based

centroid can be found in Appendix I.

Theorem 2: The COS type reducer for zSlices-based general

type-2 FLSs simplifies to the combination of the type-reduced

sets of each individual interval type-2 FLS, each associated with

their respective zLevel zi

yco s =I

i=1zi /yco si (27)

where yco s refers to the overall type-reduced set (a type-1 set)of the zSlices-based FLS. yco si is bounded by the interval[yl i , yr i ] . yco s is the combination of the type-reduced sets ateach individual zLevel referred to as yco si , which are each as-sociated with their respective zLevel zi . The type-reduced setsyco si can be found using standard interval type-reduction meth-ods such as the KM iterative procedure [3] or, alternatively,

the type-reduced sets yco si can be approximated using the Wu–Mendel uncertainty-bounds method [22]. We should note that

as in standard fuzzy logic theory, the summation sign (union

operation) in (27) implies that for any point that is associated

with more than one membership, we choose for this point themaximum of the associated membership values.

The proof of Theorem 2 can befound in Appendix II. It should

be noted that as in interval type-2 FLSs, we do not need to find

the fuzzy outputs of each rule, combine the outputs of each

fired rule, and, finally, compute the centroid of this combined

set in order to find the type-reduced set. As specified in (27),

by employing the COS type reducer for each individual zLevel,

we take the firing interval of each fired rule (which is calculated

as in interval type-2 FLSs) and the associated centroid interval

of µG̃ sz (g), and then, over all the fired rules, we calculate yco sifor that specific zLevel using the KM iterative procedure or

using the Wu–Mendel uncertainty-bounds method. Each yco siis associated to its respective zLevel zi . Hence, it can be seenthat zFLSs aggregate the outputs of several interval type-2 FLSs,

each associated with a given zLevel (i.e., zSlices). This allows

for a parallel implementation, which results in a significantly

faster computation, which, in turn, makes it possible for us to

use the zFLS for the robotic experiments presented in this paper.

Fig. 9 visualizes the type-reduction output for our example

FLS, where only one rule (rule 4) is fired. As such, Fig. 9(a)–(c)

shows the type-reduced set for eachzSlices-based general type-2

FLSs associated with the zLevels z1 , z2 , and z3 , respectively.Fig. 9(d) shows the overall type-reduced set for the zSlices-

based general type-2 FLS.

E. Defuzzification

The defuzzification step in a zFLS employs the centroid de-

fuzzifier on the type-1 fuzzy set that was generated using the

type reducer described in Section V-D. yco si in (27) is the type-reduced interval set calculated for the relevant zLevel zi . Foreach zLevel zi , this type-reduced interval is bounded by the leftendpoint (yl i ) and the right endpoint (yr i ), which could be com-puted using the iterative KM iterative procedure [3] or approx-

imated using the Wu–Mendel uncertainty-bounds method [22],

as shown in Theorem 2.

The zFLS applies the centroid defuzzifier to the type-1

type-reduced set yco s by discretizing the type-reduced


10/24


set and applying the normal centroid defuzzifier equa-

tionN −1

t=0 zi (gt ) ∗ gt /N −1

t=0 zi (gt ), where t = (yr0 − yl0 )/(N − 1), N is the number of discretization points, and g0 = yl0and gN −1 = yro , zi (gt ) is the maximum zi level correspondingto any gt according to (12). Note that all values associated withz0 = 0 will vanish from the numerator and denominator of theequation, and hence, all values associated with z0 will not affectthe total defuzzified output of the FLS. As such, the processing

of Z̃ 0 can be omitted throughout all of the zFLS as explainedearlier as they will not affect the FLS output. This is intuitive as

at z0 , the certainty about the secondary membership is 0; thus itcan be considered not to be part of the fuzzy set.

A new way particular to zFLSs to obtain the final defuzzified

outputs (which will be employed in the experiments in this paper

to speed up the processing of the FLS) is by using the fact that

each zLevel is associated with an interval type-2 FLS, where all

the type-2 fuzzy sets are zSlices with a given zLevel zi . Hence,the resultant defuzzified value of this zLevel FLS (at a given

zLevel) will be the average of the type-reduced set as in interval

type-2 FLSs. This will result in a discrete set, where we will havefor each zLevel-related FLS, the average of the type-reduced set

for this interval type-2 FLS associated with the relevant zLevel

zi . Hence, by applying the centroid defuzzifier for this discreteset, we can write as follows:

yc = (z1 ((yl1 + yr1 )/2) + z2 ((yl2 + yr2 )/2) + · · · + zI yI )

(z1 + z2 + · · · + zI ) .

(28)

Note that we have excluded the values associated with zSlice

Z̃ 0 , as they will not have any impact on the output of the zFLS(as z0 = 0, and hence, its associated terms in the numerator

and denominator of (28) are 0). As such, the process of ˜Z 0 canbe omitted throughout all of the zFLS, as we explained earlier.

From (28), it can be easily seen that the crisp output of the

zFLS is the weighted average of the outputs of the different

zLevel-induced interval type-2 FLSs (where the output of a

given interval type-2 FLS for a given zLevel zi is equal to theaverage of the left and right endpoints of the type-reduced set

for that zLevel zi , i.e., (yl + yr )/2), each associated with itsspecific zLevel. Thus, the output of the zFLS is an aggregation

of the outputs of several interval type-2 FLSs, each associated

with a specific zLevel.

This shows a great strength of zFLSs, which allows the

computation with general type-2 fuzzy sets using a series

of slightly modified interval type-2 FLSs (i.e., by employingzSlices), which, in turn, has a series of advantages as follows.

1) The fact that the complex operations on general type-2

sets can be reduced to common interval type-2 opera-

tions significantly reduces the design and implementation

complexity, and thus, facilitates the use of general type-2

FLSs.

2) The property of zFLSs that allows the computation of each

zLevel independently allows for a high degree of parallel

computation. In fact, all zSlices levels can be computed

simultaneously on separate processors followed only by

the very simple defuzzification stage, which is done cen-

trally, the output of which is fed to the system. This offers

great potential with minimal implementation effort and

should allow the use of general type-2 in a far wider set of

applications.

3) In zFLSs, current interval type-2 theory can be reused and

only very small modifications are necessary to use current

interval type-2 implementations to compute zFLSs.

4) When computing the centroid of a zSlices-based general

type-2 set as done during the type-reduction stage, the re-

sulting type-reduced type-1 set still (as for standard gen-

eral type-2 FLSs) gives an indicative model of the amount

of uncertainty contained within the current iteration of the

zFLS [as shown in Fig. 9(d)].

5) The use of zFLSs allows to achieve real-time performance

for general type-2 FLSs as a result of significant simpli-

fication of the computational complexity associated with

the deployment of general type-2 FLSs. This might lead to

the widespread deployment of general type-2 FLSs, in par-

ticular, in areas of real-world control applications, which

will allow to further explore the capabilities of general

type-2 FLSs.

F. Specification of General Type-2 Sets

One of the main challenges during the design of general

type-2 FLSs or, indeed, of any FLS is the specification of the

MFs. The choice of type of MF (such as Gaussian, triangular,

etc.) as well as the choice of their specific parameters directly

affects the FLS performance. A variety of methods to alleviate

this problem have been researched for mainly type-1 and inter-

val type-2 FLSs. Such methods are generally based on the use of

expert knowledge, evolutionary techniques (mainly genetic al-

gorithms), neural networks, and other methods. However, thereis still much work needed to standardize and simplify the selec-

tion of appropriate MFs.

In order to fully harness the potential offered by the increased

uncertainty-modeling capabilities of general type-2 FLSs (in

particular, their third dimension), we have developed an ap-

proach to determine the parameters for the MFs, which is based

on using knowledge that exists about the variables represented

by the MFs, resulting in zSlices-based fuzzy sets, such as shown

in Fig. 10(a) and (b). At the basis of the technique is the fact

that fuzzy sets/MFs can accommodate uncertainty to an extent,

which is directly dependent on the uncertainty-modeling capa-

bilities of the respective set order (type1, interval type-2, and

general type-2) (as described in Section I). While the reviewor the application of this method would be out of scope of this

paper, the full details of the method are provided in [23].

In Section VI of this paper, we have opted for standard trian-

gular MFs to represent the secondary MFs of the zFLS inputs

and outputs. This is because triangular MFs provide a simple

convex approximation of the uncertainties present in the third

dimension of the sonar inputs and the steering output. More

importantly, while the uncertainty model of the sensors and ac-

tuators is less accurate using triangular MFs, the comparison be-

tween zSlices-based general type-2, interval type-2, and type-1

sets, which is the main focus of this paper, is more reproducible

using commonly used MFs like the triangular MFs.


11/24


Fig. 10. (a)Exampleof a zSlices-based general type-2fuzzy set(three zSlices)based on accumulated data (see [23]). (a) Front view of the zSlices-based set.(b) Rear view of the zSlices-based set. (It should be noted that only the zSlices1–3 are shown; zSlice 0 has been omitted to improve visibility.) (c) Circularrobot arena. (d) Cornering wall.

VI. EXPERIMENTS AND RESULTS

A. Experimental Platform

The experimental platform we employed is based around a

two-wheeled Pioneer 2 robot, which has already been describedin [12]. Differential steering and propulsion is provided by two

electric motors, whichdrive the two robot wheels independently.

While a caster wheel maintains robot stability, this robot design

is optimized toward laboratory conditions with smooth ground

surfaces and is not well suited to uneven ground conditions,

where the small caster wheel can prevent and inhibit maneuvers,

such as acceleration and steering. This provides us with a plat-

form, which encompasses a high level of uncertainty, in terms of

performance, responsiveness, and accuracy, in conjunction with

the outdoor environment described in the following section.

While the robot is equipped with a variety of sensors, we

only utilize two sonar sensors (one toward the front of the

robot and one on its side) as inputs for the FLSs. The laser

rangefinder is used only to determine the actual distance kept to

the wall/obstacle, which is used for system-performance eval-

uation. The zFLS has one output, which is the wheel steering.

We are comparing the performance of the zFLS against the

performance of an interval type-2 FLS and a type-1 FLS. The

robot and the position of the sonar sensors have previously

been described in [12]. The systems are executed locally on the

robot via a dual-core laptop computer running Windows Vista.

It should be noted that during the execution of the zFLS, we

are exploiting the potential of zSlices in terms of employing

both processing cores of the computer in parallel to speed up

system execution. More details on the achievable performance

improvements while using multiple cores during the execution

of zFLSs are given in Section VI-E. All FLSs have been imple-

mented in JavaTM. The laptop computer interfaces to the robot

and to the laser rangefinder through serial connections.

B. Experimental Environment

The experimental environment consists of a covered out-

door circular arena [12], as well as a secondary experimental

site adjacent to the arena with a sharply cornering wall. Both

sites, which are shown in Fig. 10(c) and (d), respectively, have

been surfaced with standard road tarmac, which is uneven at

many places. Additionally, small pebbles, thick parking-space

paint markings, dust, wind, and varying levels of humidity af-

fect the robot performance and introduce additional sources of

uncertainty.

C. System Designs

The main goal of the robot in the following experiments is toimplement a right edge-following behavior to follow the edge at

a desired distance from the edge. For the zFLS, each of the two

sensor inputs is modeled by two zSlices-based general type-2

fuzzy MFs (zMFs), which represent the linguistic labels near

and far , respectively. In the chosen zMFs, the primary MFs were

based on boundary trapezoidal MFs, and the secondary MFs

were based on triangular MFs with four zSlices. The number of

four zSlices has been chosen as it results in a computationally

non-expensive system and facilitates the visualization of the

fuzzy sets. As explained earlier, we have opted for triangular

MFs to represent the secondary MFs of the zFLS inputs and

outputs, as they provide a simple convex approximation for the

uncertainties in the third dimension of the sonar inputs andthe steering output. More importantly, the comparison between

zSlices-based general type-2, interval type-2, and type-1 sets,

which is the main focus of this paper, is more reproducible

using commonly used MFs like the triangular MFs. It should be

noted that all MFs in this paper have been designed empirically

through expert knowledge, and an automatic optimization of

MF parameters will be investigated in the future.

The MFs for both inputs are identical except for the positions

of the zMFs along the x-axis. The position has been modifiedto account for the different positions of the sonar sensors, i.e.,

while the side sonar faces the wall/obstacle directly, the front

sensor faces the wall/obstacle at a 40◦

angle (see [12]). Fig. 11


12/24


Fig. 11. (a) Full 3-D visualization of the zMFs for front sonar. (b) Simplified 3-D visualization of the zMFs (near (blue) and far (red) for the front sonar.(c) Simplified 3-D visualization of the zMFs near (blue) and far (red) for the side sonar. (Distance unit is in millimeters).

Fig. 12. (a) zMFs left (blue) and right (red) for steering output. (b) Interval type-2 MFs near (blue) and far (red) for front sonar. (c) Interval type-2 MFs near(blue) and far (red) for side sonar. (d) Interval type-2 MFs left (blue) and right (red) for Output. (Distance unit in (b) and (c) in millimeters).

shows the zMFs for the near and far linguistic labels for the

front and side sonars in full 3-D [see Fig. 11(a)] and simplified

3-D [see Fig. 11(b) and (c)]. The simplified 3-D visualization inFigs. 11(b) and (c) and 12(a) demonstrates a simplified visual-

ization for zMFs, which will be used in this section, where all

four zSlices are shown with the decrease of FOU from zSlice 1

to zSlice 4 being visible. It is worth noting that zSlice 0 is not

required for computation as explained earlier and as such is not

shown in the figures. The steering output of the zFLS shown

in Fig. 12(a) is modeled using two triangular zMFs (using four

zSlices) that represent the linguistic labels(left and right, respec-

tively), which are defined on the interval [0, 100]. The steering

output encodes the turning direction, where 0 represents a hard

left and 100 represents a hard right turn. It should be noted that

in accordance with zSlices theory, all zMFs within the zFLS

have identical zLevels. The fuzzy rule base, which is identicalin structure to that in other Mamdani-type FLSs contains four

rules, which are listed in Table II.

In order to compare the zFLS to an interval type-2 FLS, an

interval type-2 FLS implementing the same set of rules as the

zFLS was created. The input MFs for the interval type-2 FLS

were extracted from the zMFs of the zFLS in order to allow for

a fair comparison between both systems. This extraction was

achieved by selecting zSlice 0 from all zMFs and changing its

zLevel to 1 instead of 0, thus resulting in the standard inter-

val type-2 fuzzy set input MFs shown in Fig. 12(b) and (c) for

the front and side sonars, respectively. The interval type-2 out-

put MFs displayed in Fig. 12(d) were generated in an identical

fashion using zSlice 0 of the output sets from the zFLS. The

type-1 system used for comparison was also implemented using

anidentical rulebase tothe zFLS. In order toallow for a faircom-parison, the actual type-1 MFs were generated from the zMFs

by utilizing the fact that Z I , in our case Z 4 , is, in fact, a type-1set. The extracted type-1 input MFs are depicted in Fig. 13.

D. Experimental Results

We will present the results of two proof-of-concept exper-

iments, which are both based on the comparison of the same

FLSs implementing the edge-following behavior. The experi-

ments have been concluded in two different settings/sites. The

main objective to concluding two different experiments was to

investigate the different aspects related to the type-1 FLS, inter-

val type-2 FLS, and zFLS, in particular, in terms of how eachFLS handles the uncertainty present in the experiments while

maintaining its main goal, which is following an edge at the

distance specified. It should be noted that our objective is not to

show the superiority of either type of FLS (which—if possible

in the general case at all—requires elaborate investigation and

experimentation by multiple researchers over years to come) but

to provide an initial investigation based on a very small set of

experiments, which allows us to present some interesting early

findings on the properties of different types of FLSs.

In Fig. 14, we present the control surfaces of the three FLSs.

It can be seen that the interval type-2 FLS’s control surface is

significantly smoother than the type-1 FLS’s, while the control


13/24


Fig. 13. (a) Type-1 MFs left (blue) and right (red) for output. (b) Type-1 MFs near (blue) and far (red) for front sonar. (c) Type-1 MFs near (blue) and far (red)for side sonar. (Distance unit in (b) and (c) in millimeters).

surface of the zFLS seems to be the smoothest of all three con-

trol surfaces. The zFLS’s smooth control surface maps to a very

good control performance that can handle the uncertainties and

disturbances, particularly near the set point (where the side and

front sonar sensors are at the desired distance from the edge)

where small variations in the values of the front and side sonarswill not cause significant changes to the steering output. The

interval type-2 FLS also provides a smooth response near the

set point; however, the area around the set point, (i.e., the ridges

above and below the center of the control surface) is effectively

“flat” and does not continuously “increase from left to right”

as it does for the type-1 FLS and the zFLS. This results in a

much less-responsive control output (compared with the zFLS)

when facing sudden significant changes in FLS inputs or the

environment. As can be seen from Fig. 14, the zFLS’s response

progresses gradually and smoothly with no steep changes. On

the other hand, the overall less-smooth control surfaces of the

type-1 and interval type-2 FLSs result in a slightly cruder con-

trol response in comparison to the zFLS, as will be shownlater in Section VI-D1. We will present real-world experiments,

which involvethe edge-following behavior in a circular arena. In

Section VI-D2, we will present another set of experiments

comparing the FLSs performances in implementing the edge-

following behavior around a corner in an outdoor environment.

1) FLS-Performance Comparison for Edge Following Within

a Circular Arena: In this section, we will present the results of

the experiments that investigated the performance of three FLSs

(type-1 FLS, interval type-2 FLS, and zFLS) that implemented

the edge-following behavior using the Pioneer robot, which was

positioned in the circular arena described in Section VI-B. Two

different starting positions were chosen for the robot: one at agreater distance (position 1) and the other at a shorter distance

(position 2) than the desired distance specified for the edge-

following behavior. Each FLS was executed from each starting

position for six separate runs in order to check the consistency

of each FLS performance.

The different robot paths from starting positions 1 and 2 are

shown in Figs. 15 and 16, respectively. Figs. 15 and 16 also

show the averages (over the six separate runs from each posi-

tion) of the robot performance measures, which are the average

error (absolute value of difference between actual distance kept

to the edge and desired distance), the standard deviation, and the

Root Mean Squared Error (RMSE). While it is very difficult to

make conclusions on performance from the graphical-path plots

alone, the mathematical-performance measures give a clear in-

dication of differences between the different systems. Table III

summarizes the results of the experiments for clarity and addi-

tionally provides the average results of both starting positions.

It is clear that the small number of experiments executed as partof the Section VI-D2 in this paper cannot be considered repre-

sentative, and thus, the statistics in Tables III and IV summarize

these proof-of-concept experiments but should not be gener-

alized. Nevertheless, the results give a good initial indication

of the potential of the individual FLSs, which will hopefully

be further investigated by future experiments in a variety of

settings.

When considering the average values of the average errors

in the distance maintained to the edge by the different FLSs,

it can be seen that the interval type-2 FLS shows the highest

performance with an average of 160 mm, followed by the zFLS

with an average of 171 mm and the type-1 FLS with an average

of 177 mm. The same pattern is followed for the average valuesof theRMSEs, where the interval type-2 FLSprovidesthe lowest

RMSE followed by the zFLS and, finally, the type-1 FLS.

Considering the standard deviations for the three systems, we

can see that the interval type-2 FLS gives the largest standard

deviation compared with the zFLS and type-1 FLS. This indi-

cates that the zFLS is more consistent when compared with the

interval type-2 FLS. These results are consistent with the re-

sults reported in [16], which has shown that the general type-2

FLS response is more consistent in face of uncertainties when

compared with the interval type-2 FLS.

By considering the uncertainty-modeling capabilities of the

three systems, it becomes clear that the relatively-high levelsof uncertainty included in the interval type-2 FLS result in a

reduced responsiveness and, thus, low consistency when com-

pared with the zFLS (i.e., the pressure on the robot to correct its

position is less strong unless the robot has deviated significantly

from its position). However, the zFLS, which allows to accu-

rately model the uncertainty present in the problem, and thus,

should provide the best compromise, results in a smooth as well

as timely and responsive control output.

A closer look at the way the different FLSs model uncertainty

gives a good indication in terms of the sources of these results.

As previously mentioned and indicated in Fig. 1, the amount of

uncertainty modeled by fuzzy sets is smallest for type-1 sets,


14/24


Fig. 14. Control surfaces of (a) type-1 FLS, (b) interval type-2 FLS, and(c) zFLS.

larger for general type-2 sets, and largest (i.e., full) for interval

type-2sets. It seems intuitive that the type-1 FLS, which hasonly

very limited potential to model uncertainty will provide a crude

and drastic control output, which will result in poor performance

when handling high levels of uncertainties. The interval type-2

FLS with the largest amount of uncertainty associated with its

sets, on the other hand, should provide a much smoother con-

trol response, and thus, superior results. However, as can be

seen in the next section, the interval type-2 FLSs cannot al-

ways maintain a reliable and responsive control output while

they allow such high levels of uncertainty and, thus, result in a

Fig. 15. Experiment 1 robot paths and average performance measures for allFLSs, started from position 1. (a) Type-1 FLS path. (b) Interval type-2 FLS.(c) zSlices-based general type-2 FLS (unit: millimeters).

performance that is not as consistent as that of zFLSs. Finally,

the zFLS, which allows for a more accurate model (while notcompletely accurate as the third dimension is based on simple

triangles in this paper) of the uncertainty actually present in

the problem provides a smooth as well as timely and responsive

control output. It should be noted that the zFLS like any FLS can

achieve its full potential when employing optimization methods

to find the “optimal” parameters for the MFs parameters, which

is the subject for our future work.

In Figs. 15 and 16, it should be noted that the wall position

(dotted in red) has been determined individually during each

specific experimental run of the robot. As the robot position in

the global frame of reference is subject to odometry errors (i.e.,

errors in the tracking of the position of the robot in relation


15/24


Fig. 16. Experiment 1 robot paths and average performance measures for allFLSs, started from position 2. (a) Type-1 FLS path. (b) Interval type-2 FLS.(c) zSlices-based general type-2 FLS. (unit: millimeters).

to the global frame resulting from the real-world nature of theexperiment), the combination of all the individual robot paths

creates this slightly blurred representation of the wall position.

This, however, does not affect the result evaluation in terms of

averages of errors, standard deviations, RMSEs, or their respec-

tive averages as these mathematical metrics are computed for

each specific run separately and only later combined to produce

the averages.

2) FLS-Performance Comparison for Edge Following Round

a Corner: In the second set of experiments, we have investi-

gated the responsiveness of the different FLSs when presented

with high uncertainty levels, combined with a sudden significant

change in the FLS inputs. The sudden change was introduced

TABLE IIIEXPERIMENT 1 RESULTS (UNIT: MILLIMETERS) (RESULTS ARE SUMMARIZING

SIX RUNS PER STARTING POSITION)

TABLE IVEXPERIMENT 2 RESULTS (UNIT: MILLIMETERS) (RESULTS ARE SUMMARIZING

SIX RUNS PER STARTING POSITION)

within the edge-following context by introduction of the robot

to a corner edge [shown in Fig. 10(d)].

In this set of experiments, each of the three FLSs was placed

in two different starting positions: one at a shorter distance


16/24


(position 1) and the other at a greater distance (position 2) than

the desired distance specified for the edge-following behavior.

Each FLS was executed from each starting position for six sepa-

rate runs in order to check the consistency of each FLS’s perfor-

mance. As in the previous set of experiments, the FLS’s perfor-

mance indicators (the average error, the standard deviation, and

RMSE) are averaged and presented for each of the FLSs in

Table IV. Additionally, Table IV contains the average per-

formance values of both starting positions for each of the

FLSs.

The actual robot runs for starting positions 1 and 2 have been

included in Figs. 17 and 18, respectively. When considering the

results, the zFLS average error of 168.5 is significantly superior

(in terms of performance) to the type-1 FLS and the interval

type-2 FLS. This indicates that the zFLS maintains a smaller

error with respect to the desired wall distance. The interval

type-2 FLS achieves the worst performance while the type-1

FLS produces a smaller average error. The same results are ob-

tained for the RMSEs, which indicate that the best performance

is achieved by the zFLS.The reason for the results is the amount of uncertainty con-

tained within the different FLSs’ MFs. The type-1 FLS has a

very limited amount of uncertainty associated with its MFs (see

Fig. 1), which allows it to respond quickly to the drastically

different situation the robot encounters when passing the cor-

ner of the wall. Nevertheless, it cannot model the uncertainty

present in the environment and, thus, cannot achieve a very high

performance as shown in the previous set of experiments. The

interval type-2 FLS, on the other hand, has a very high level of

uncertainty associated with its MFs, which allows it to model the

uncertainty in its environment (even if not accurately). However,

this very high level of uncertainty inhibits it from a responsivecontrol response when faced with the drastically different sit-

uation after the robot passes the turn in the wall and, hence,

compromises its performance significantly. This is visible in the

control-surfaces analysis in Fig. 14, where Fig. 14(a) shows the

sharp rise in the control surface of the type-1 FLS, which results

in a responsive but crude control performance. In Fig. 14(b),

it is visible that the high uncertainty levels associated with the

interval type-2 FLS result in a smooth control surface; however,

they also result in the previously described “ridges” near the set

point, which results in a slow change in the control output com-

pared with the zFLS. This, in turn, results in a less-responsive

performance when facing sudden and significant changes in the

FLS inputs and the environment. The zFLS [the control surfaceof which is shown in Fig. 14(c)] combines a certain amount of

uncertainty modeling within its MFs, which allows the zFLS

to react appropriately to the drastic change in environment and

model the present uncertainty throughout the run.

As in the experimental run reported in the previous section,

the averages of the standard deviations indicate that the zFLS

produces a more consistent performance than the interval type-2

FLS. Again these results, which are in accordance with the re-

sults reported in [16], point toward the fact that the high amount

of uncertainty contained within the interval type-2 MFs results

in a quite variable-control response and output, which is not

always desirable.

Fig. 17. Experiment 2 robot paths and average performance measures forall FLSs, started from position 1. (a) Type-1 FLS. (b) Interval type-2 FLS.(c) zSlices-based general type-2 FLS (unit: millimeters).

From the experimental results reported in the previous two

sections, it is noticed that the zFLSs will give a similar per-

formance (or slightly worse performance) when compared with


17/24


Fig. 18. Experiment 2 robot paths and average performance measures forall FLSs, started from position 2. (a) Type-1 FLS. (b) Interval type-2 FLS.(c) zSlices-based general type-2 FLS (unit: millimeters).

interval type-2 FLSs in terms of average error and RMSEs,

as long as no drastic changes to the FLS inputs are present,

while outperforming the interval type-2 FLS in terms of stan-

dard deviation, i.e., consistency. However, when the FLS inputs

change drastically (as was imposed in the second experimental

setup), the zFLS provides a significantly better performance in

terms of less average error and RMSEs when compared to the

corresponding interval type-2 and type-1 FLSs.

In all cases, it was shown that the zFLS gives a more consis-

tent performance when compared with the interval type-2 FLS,

which is in accordance with the results published in [16]. This

shows that the zFLS is a good compromise in terms of providing

a consistent and good performance when facing the uncertain-

ties generally encountered in real-world environments. This is

because of the fact that zFLSs can model the uncertainties more

accurately when compared with interval type-2 FLSs and type-1

FLSs, and as the accuracy of this uncertainty model increases,

the performance of the zSlices-based general type-2 FLS is only

set to improve further.

E. Computational Performance Analysis of the zFLSs

In order to investigate the performance of zFLSs in termsof computational requirements, in particular, when exploiting

the fact that the zFLS framework enables the execution of the

zFLS on parallel processors (cores), we have run a series of

experiments to compare our multicore microprocessor imple-

mentation with a standard, single-core implementation. While

in the multicore implementation, multiple (or even all) zSlices

levels of the zFLS can be computed in parallel using nearly

unmodified standard interval type-2 algorithms, in the single-

core algorithm, all the zSlices levels are computed in sequence

before a final output is computed.

We have used the zFLS to implement an edge-following be-

havior described in this paper as the basis for our performanceanalysis. The system’s input ranges were discretized into 101

steps for both inputs, which resulted in a total of 10 201 sam-

pling points. Discretizing the inputs allowed us to ensure that

the FLS was evaluated adequately and to avoid special cases,

where, for example, only very few rules are executed, which, in

turn, would result in an erroneous performance evaluation.

The experiments were executed on an 8-core microprocessor

workstation and both the single- and the multicore implemen-

tations were implemented in Java. Fig. 19(a) shows the average

time (across all 10 201 samples) required per control cycle for

an increasing number of zSlices. It is clear from Fig. 19(a)

that the multicore zSlices implementation vastly outperforms

the single-core implementation in terms of computation speedas the number of zSlices increases. This is expected as the

single-core implementation needs to evaluate every zSlice in

sequence, while they can be computed in parallel using the

multicore implementation. As such, the zSlices implementation

can take full advantage of the multicore architecture, which is

quickly becoming the standard for workstations. It should be

noted that even at eight zSlices, the multicore implementation is

still very competitive and, with an average time per control cy-

cle of 24.5 ms, still outperforms the single-core implementation,

which uses only two zSlices, which requires 25.5 ms per control

cycle. At eight zSlices, the single-core implementation requires

111 ms compared with 24 ms for the multicore implementation.


18/24


Fig. 19. (a) Comparison of the average time required by the single and themulticore zSlices implementation using different numbers of zSlices. (b) Aver-age time per control cycle using the multicore implementation as the number of zSlices increases to 16.

In addition to the aforementioned comparison, we have evalu-

ated the performance of the multicore zFLS implementation foreven higher number of zSlices in order to investigate the per-

formance when the number of zSlices is larger than the number

of cores available (and as such, every core has to process more

than one zSlice). Fig. 19(b) shows the performance of the mul-

ticore implementation with up to 16 zSlices. From Fig. 19(b),

it can be seen that the performance does not deteriorate dras-

tically when the number of zSlices is larger than the number

of cores available (eight in our case). One could have expected

the performance to decrease drastically as soon as the number

of cores was inferior to the number of zSlices, but this is not

the case. The reason for this is that during the computation of a

control cycle, some zSlices will be computed significantly faster

than others (e.g., fewer rules fire as the zLevel increases as theFOU of the zSlices decreases in size, i.e., the primary degree of

membership for zSlices becomes 0 for more inputs for zSlices

at higher zLevels), and as such, the processor cores can imme-

diately start the computation of another zSlice. This allows the

multicore zSlices implementation to benefit significantly from

multiple cores even if the number of zSlices is higher than the

number of processing cores available.

The dramatic increase in performance provided by the mul-

ticore zSlices implementation makes the use of general type-2

FLS a realistic possibility in control applications today, even

when reasonably large numbers of zSlices, and as such, high

precision in uncertainty modeling is used. This also offers the

potential for employing complex general type-2 FLSs in a dis-

tributed computing environment.

Finally, we would like to add that the multicore implemen-

tation is still under development and the overheads, which are

still present currently, will hopefully be decreased in the future

and help to speed up the computation. It should also be noted

that the zFLS shown here does not employ any speed-enhancing

techniques, such as the uncertainty-bounds technique described

in [22], which offer another direction for future performance

improvements.

While this paper focuses mainly on the establishment of the

theoretical foundations of zFLSs, the performance characteris-

tics of the zFLS framework are of particular relevance to the

real-world applicability of (zSlices-based) general type-2 fuzzy

systems. The possibility for multicore implementation as well as

the similarity to existing interval type-2 implementations (and

as such their reuse) should facilitate the deployment of zFLSs

in industrial applications facing large amounts of uncertainty

while requiring real-time performance (for example, through

field-programmable gate-array implementation based on the in-terval type-2 design shown in [24]) at minimal development and

implementation cost.

F. Computational Performance Comparison of Type-1,

Interval Type-2, zSlices-Based, and Standard General

Type-2 FLS Operations

The computational performance of FLSs is generally deter-

mined by the computational complexity of the operations, which

are employed during the different stages of the specific FLS.

In order to allow for a computational-performance comparison

between zSlices-based and standard general type-2 FLSs (and

type-1 and interval type-2 FLSs, where applicable), we are re-viewing the computational complexity of the most important

FLS operations, in particular, the union, the intersection (imple-

mented through the join and meet operation, respectively), and

the centroid operations.

1) Computational Complexity of the Join and Meet Opera-

tions: Consider M discretization of the x-axis (i.e., the numberof vertical slices) and N discretization of the y-axis. Then, thenumber of operations Os for the computation of the join or meetoperation between two standard general type-2 fuzzy sets is [8]

Os = M ∗ N 2 . (29)

This number of operations Os represents M ∗ N 2 t-norm/ t-conorm operations.

For two zSlices-based general type-2 fuzzy sets, with I beingthe number of zSlices andM beingthe number of discretizationsof the x-axis (i.e., the number of vertical slices), the number of operations Oz required for the computation of the join or meetoperations rises in a linear fashion

Oz = 2 ∗ M ∗ I. (30)

This number of operations Oz represents M ∗ 2 ∗ I t-norm/ t-conorm operations, where the multiplier 2 is introduced by the

requirement for considering the left and right endpoints for each

zSlice.


19/24


TABLE VCOMPARISON OF THE NUMBER OF OPERATIONS REQUIRED TO COMPUTE THE

JOIN OR MEET OPERATION FOR DIFFERENT TYPES OF FUZZY SETS

Fig. 20. Number of computational operations required for the computationof the join/meet operations for zSlices based (Oz ) and standard (Os ) generaltype-2, interval type-2 (Oi ), and type-1 (O) fuzzy sets.

Additionally, the number of operations Oi required to com-pute the join or the meet operation of two interval type-2 fuzzy

sets is as follows:

Oi = 2 ∗ M. (31)

For completeness, it is worth noting that for type-1 fuzzy sets,

the number of operations O is simply

O = M. (32)

Equation (30) clearly shows thelinear progression of thenum-

ber of operations required when using zSlices compared with

the exponential increase of operations required when utilizing

the standard general type-2 sets. Furthermore, comparing (30)

and (31) indicates, as expected, that the calculation of the join

or meet operation on a zSlices-based type-2 fuzzy set requires

I times the number of operations of an equivalently discretizedinterval type-2 set.

Table V and Fig. 20 give an indication of the number of op-

erations required to compute the join or meet operations for dif-

ferent fuzzy logic sets, where N and I were kept at equal values

and M was kept constant at 100. Table V shows the significantlysmaller number of operations required by the zSlices in com-

parison to using the standard general type-2 method, especially

as the precision of describing the general type-2 fuzzy set in-

creases (as indicated by the increasing number of discretization

steps).

Thesignificant reduction in the number of operations required

to compute the join and meet operations on zSlices-based gen-

eral type-2 fuzzy sets compared with standard general type-2

fuzzy sets has been shown, and some details on the computa-

tional complexity of the centroid operation are given next.

2) Computational Complexity of the Centroid Operation: In

order to compare the complexity of the centroid operation (a

comparison, which also applies to the type-reduction step in

FSs) on zSlices-based and standard general type-2 fuzzy sets,

it is important to consider that the standard centroid operation

for general type-2 fuzzy sets while theoretically sound is practi-

cally unusable, as described in Section III-D. The complexity of

the zSlices-based centroid operation reduces to the calculation

of the centroid calculation of each zLevel, which, as shown in

Theorem 1, can be accomplished using standard interval type-2

algorithms. After each zLevel’s centroid has been computed, a

simple weighted average operation allows the computation of

the overall centroid, as depicted in Fig. 9. The complexity of

the overall operation is roughly equivalent to I × the complex-ity of an interval type-2 centroid calculation (where I is thenumber of zLevels). While the paper-size restrictions prevent us

from supplying additional examples, it is clear that zSlices pro-

vide a vast complexity reduction compared with standard gen-

eral type-2 and their real-world applicability has been shown in

Section VI of this paper.

VII. CONCLUSION

In this paper, we have presented the complete theoretical

framework for zSlices-based general type-2 FLSs. zSlices rep-

resent a novel representation for general type-2 fuzzy sets and

allow the application of general type-2 FLSs using today’s hard-

ware at a minimal increase in complexity when compared with

interval type-2 FLSs. We have included proofs and examples

of all major items involved in zFLSs operations (except the

proofs for the union and the intersection operations, which we

have included in [9]), in particular, the join, meet, centroid, and

type-reduction operations. Additionally, we have given a com-

plete description (including examples) of all the steps involvedin the implementation of a zFLS. Furthermore, we have imple-

mented a complete zSlices-based general type-2 FLS for the

edge-following behavior of a real two-wheeled robot and tested

it in two experimental setups, both set in real-world outdoor en-

vironments. We have compared the zFLS performance against a

type-1 and an interval type-2 FLS, where the MFs of both FLSs

were deduced from the zSlices-based general type-2 MFs used

in the zFLS.

The complex nature of the uncertainty encountered in the real

world indicates the complex shape that general type-2 sets are

bound to have if they model the uncertainty present in real-world

devices and applications. While other approaches, such as [5]

and [6] address general type-2 sets based on triangular or trape-zoidal general type-2 fuzzy sets, they do not consider complex

general type-2 fuzzy sets. We have described how zSlices can be

used to model these sets to an arbitrary degree of accuracy only

dependent on the numbers of zSlices. This flexibility, in com-

bination with the implementation and computational simplicity,

make zSlices-based general type-2 FLSs a unique option for

the computation of general type-2 FLSs. Furthermore, we have

shown how the different capabilities to model a certain amount

of uncertainty in different types of FLSs result in a different con-

trol response, which is a topic we feel is highly crucial and needs

to be investigated further. In particular, we have identified the

large amount of uncertainty encompassed in interval type-2 sets


20/24


as a potential weakness in situations, where such high amount of

uncertainty is not present and/or where a very responsive control

response is required. As part of the supplied proof-of-concept

experiments, we have shown that (zSlices-based) general

type-2 fuzzy sets potentially suffer less from this problem and

it is reasonable to expect that an accurate model of the uncer-

tainty in the third dimension will further alleviate the problem,

while maintaining a smooth control response. Even in a setting

of nonoptimized

Documents

Type Reduction of Fls-t2