This paper presents two new algorithms that speed up the centroid computation of an interval type-2 fuzzy set. The algorithms include precomputation of the main operations and initialization based on the concept of uncertainty bounds. Simulations over different kinds of footprints of uncertainty reveal that the new algorithms achieve computation time reductions with respect to the Enhanced-Karnik algorithm, ranging from 40 to 70%. The results suggest that the initialization used in the new algorithms effectively reduces the number of iterations to compute the extreme points of the interval centroid while precomputation reduces the computational cost of each iteration.
1. Introduction
Type-2 fuzzy logic systems (T2-FLS) theory and its applications have grown in recent years [1–3]. One of the main problems related to the implementation of these systems is type reduction, which computes the generalized centroid of a type-2 fuzzy set (T2-FS) [4–6]. This operation becomes computationally simpler when performed over a particular class of T2-FS, namely, interval type-2 fuzzy set (IT2-FS) [5, 7]. Basically, the centroid of an IT2-FS is an interval [3, 8]. Therefore, computing this centroid can be considered as an optimization problem that finds the extreme points that define the interval [6].
Fast computation of type reduction for IT2-FSs is an attractive problem, which is critical since type-reduction procedures for more general type-2 fuzzy sets (T2-FSs) make use of interval type-2 fuzzy computations [4, 9–11]. Up-to-date, several iterative approaches to computing type reduction for IT2-FSs have been proposed [5, 12–18]. The Karnik-Mendel (KM) algorithms are the most popular procedures used in interval type-2 fuzzy logic systems (IT2-FLS) [17]. It has been demonstrated that the KM algorithms converge monotonically and superexponentially fast. These properties are highly desirable in iterative algorithms [13]. However, KM procedures converge in several iterations and demand a considerable amount of arithmetic and memory look-up operations [7, 8, 12, 19], for real IT2-FLS implementations.
In the case of IT2 fuzzy controllers, the computational cost of type reduction is an important subject [20, 21]. The overall complexity of the controller largely depends on the type-reduction and defuzzification stages. Thus developing strategies for reducing the computational burden and necessary resources for implementing these two stages is highly convenient. In addition, there are other applications of IT2-FLS in which the complexity of the hardware and software platforms should be reduced in order to guarantee the fastest possible execution of fuzzy inferences [22, 23].
Noniterative type reduction of IT2-FS can be achieved by means of uncertainty bounds [7]; however, this method is approximate and involves relatively complex computations. Other methods for computing the centroid of an IT2-FS have been proposed, for example, geometric type-reduction [4], genetically optimized type-reducers [8], interval-analysis-based type-reduction [24], and sampling defuzzification and collapsing defuzzification [12]. Although these alternative methods exhibit interesting properties, they are not as popular as the KM algorithm.
An enhanced version of the KM algorithm (EKM) was presented in [16]. This version includes a better initialization and some computational improvements. Experimental evidence shows that the EKM algorithm saves about two iterations, which means a reduction in computation time of more than 39% with respect to the original algorithm. By the time the EKM algorithm was presented, and the iterative algorithm with stop condition (IASC) was also introduced by Melgarejo et al. [14, 15, 19]. This algorithm deals with the problem of computing type-reduction for an IT2-FS by using some properties of the centroid function [13, 19]. Experimental evidence showed that IASC is faster than the EKM algorithm in some cases.
Recently, IASC has been enhanced by Wu and Nie [18] leading to a new version called EIASC, which proved to be the fastest algorithm with respect to the IASC and EKM algorithms for several type-2 fuzzy logic applications. The improvement introduced in EIASC mainly deals with modifying the iterative procedure for computing the right point of the interval centroid. Although IASC and EIASC outperform the EKM algorithm, the initialization of the IASC-type algorithms is somewhat trivial and does not provide an appropriate starting point, which can limit the convergence speed of these algorithms when calculating the points of the type-reduced set. An extensive and interesting comparison of several type-reduction methods is provided by Wu in [25]. This study confirmed the convenience of EIASC over the EKMA for reducing the computational cost of an IT2-FLS. The experiments that were limited to interpreted language implementations also showed that EIASC and the enhanced opposite direction searching algorithm (EODS) exhibited similar performance over different applications; however, the EODS outperformed EIASC in low-resolution cases [26].
Regarding the aforementioned problem, this work considers a different initialization perspective for iterative type-reduction algorithms based on the concept of inner-bound set for a type-reduced set [13]. This kind of initialization has not been tried in type-reduction computing until now. As it will be analyzed later, the inner-bound initialization reduces the distance that the algorithms need to cover in order to find the optimal points of the interval centroid. In addition, bearing in mind the computational burden of iterative algorithms, this paper also focuses on proposing an alternative strategy to speed up their computation based on the concept of precomputing. Precomputation in algorithmic design is a powerful concept that reduces the necessary arithmetic operations. Current literature does not report the use of precomputation in the type-reduction stage in IT2-FLSs.
Using inner bound sets initialization and precomputation, Both the IASC and KM algorithms have been restated, leading to faster algorithms hereafter refered to IASC2 and KMA2. Our experiments considering two different implementation perspectives (i.e., interpreted language and compiled language) show that IASC2 and KMA2 outperform EKMA and EIASC. In fact, timing results suggest that IASC2 may be the best option for implementing IT2-FLSs in dedicated hardware, whereas EKMA may support the computation of large-scale simulations of IT2-FLSs over general purpose processors.
The paper is organized as follows. Section 2 provides some background about the centroid of an interval type-2 fuzzy set. IASC2 and KMA2 are presented in Section 3. Section 4 is devoted to a computational comparative study of iterative type-reduction methods which considers two types of implementation: compiled-language-based and interpreted-language-based. Finally, we draw conclusions in Section 5.
2. Background
The purpose of this section is to provide some basic information about the centroid of interval type-2 fuzzy sets. The reader who is not familiar with this theory is invited to consult [3, 5, 13] among others.
2.1. Type-2 Fuzzy Sets
According to Mendel [5] a type-2 fuzzy set, denoted A~, is characterized by a type-2 membership function μA~(x,u) where x∈X and 0≤μA~(x,u)≤1:
(1)A~={((x,u),μA~(x,u))∣∀u∈Jx⊆[0,1]}.
2.2. Interval Type-2 Fuzzy Sets
An IT2-FS is a particular case of a T2-FS whose values in μA~(x,u) are equal to one [27]. An IT2-FS is fully described by its footprint of uncertainty (FOU) [3]. Note that an IT2-FS set can be understood as a collection of type-1 fuzzy sets (i.e., traditional fuzzy sets). The membership functions of these sets are contained within the FOU; thus, they are called embedded fuzzy sets [5, 13].
2.3. Centroid of an IT2-FS
Let A~ be an IT2-FS, and its centroid c(A~) is an interval given by [5]:
(2)c(A~)=1[yl(A~),yr(A~)]=1[yl,yr],
where yL and yR are the solutions to the following optimization problems:
(3)yL=min∀fi∈[fi_,fi¯]∑i=1Nxifi∑i=1Nfi,yR=max∀fi∈[fi_,fi¯]∑i=1Nxifi∑i=1Nfi,
where the universe of discourse X as well as the upper and lower membership functions have been discretized in N points.
A simpler way to understand the centroid of an IT2-FS is to think about it as a set of centroids that are computed from all the embedded fuzzy sets [3, 5]. Clearly, in order to characterize an interval set, it is only necessary to find its minimum and maximum. The Karnik-Mendel iterative algorithms [5, 16, 17] are the most popular procedures for computing these two points.
2.4. Computing the Centroid of an IT2-FS
It has been demonstrated that yL and yR can be computed in terms of the upper and lower membership functions of the footprint of uncertainty (FOU) of A~ [3, 5] as follows:
(4)yL=min∀fi∈[fi_,fi¯]∑i=1Nxifi∑i=1Nfi=∑i=1Lxifi¯+∑i=L+1Nxifi_∑i=1Lfi¯+∑i=L+1Nfi_,yR=max∀fi∈[fi_,fi¯]∑i=1Nxifi∑i=1Nfi=∑i=1Rxifi_+∑i=R+1Nxifi¯∑i=1Rfi_+∑i=R+1Nfi¯,
where fi_ and fi¯ are the values of the lower and upper membership functions, respectively, considering that the universe of discourse X has been discretized into N points xi. In addition L and R are two switch points that satisfy the following:
(5)xL≤yL≤xL+1,xR≤yR≤xR+1.
2.5. Uncertainty Bounds of the Type-Reduced Set
The type-reduced set of an interval type-2 fuzzy given in (2) can be approximated by means of two interval sets called inner- and outer-bound sets [7]. The end yL and yR points of the type-reduced set of an interval type-2 fuzzy set are bounded from below and above by
(6)yl_≤yL≤yl¯,(7)yr_≤yR≤yr¯,
where [yl¯,yr_] and [yl_,yr¯] are the inner- and outer-bound sets, respectively. For the purposes of this paper only the inner bound set is considered, so it is computed as follows:
(8)yA=∑i=1Nxifi¯∑i=1Nfi¯,yB=∑i=1Nxifi_∑i=1Nfi_,(9)yl¯=min(yA,yB),yr_=max(yA,yB).
2.6. Properties of the Centroid Function
The definition and corresponding study of the continuous centroid function are provided by Mendel and Liu in [13]. Theoretical studies derived from (6) can be legitimated for the discrete centroid function [12]. Regarding this fact, Mendel and Liu demonstrated several interesting properties of the continuous centroid function, which are applicable also to the discrete one. Some of these properties can be summarized saying that the centroid function decreases or has flat spots to the left of its minimum, and it increases or has flat spots to the right of this value. Additionally, this function has a global minimum when k=L. The right-centroid function yr has similar properties since this function has a global maximum when k=R. Thus, it increases to the left of the maximum and decreases to the right.
3. Modified Iterative Algorithms for Computing the Centroid of an Interval Type-2 Fuzzy Set3.1. IASC2
The IASC-2 algorithm is presented in Table 1. The algorithm consists of four stages: sorting, precomputation, initialization, and recursion. Sorting and precomputation are the same for computing yL and yR. Precomputation stores the partial results of computing (8); only two divisions are required. Those results will be used along the other stages of the algorithm.
IASC2 algorithm flow.
IASC2
The minimum extreme point yL of the centroid of an interval type-2 fuzzy set over xi with upper membership function fi¯ and lower membership function fi_ can be computed using the following procedure:
The maximum extreme point yR of the centroid of an interval type-2 fuzzy set over xi with upper membership function fi¯ and lower membership function fi_ can be computed by the following procedure:
(1) Sort xi(i=1,2,…,N) in ascending order and call the sorted xi by the same name, but now x1≤x2≤⋯≤xN. Match the weights fi with their respective xi and renumber them so that their index corresponds to the renumbered xi.
(2) Precomputation:
V[n]=∑i=1nfi¯ (15)
H[n]=∑i=1nfi_ (16)
T[n]=∑i=1nxifi¯(17)
Z[n]=∑i=1nxifi_(18)
with n=1,2,…N.
yA=T[N]V[N] (19)
yB=Z[N]H[N] (20)
(3) Initialization:
Initialization:
ymin=min(yA,yB)
(21)
ymax=max(yA,yB)
(32)
Find Li(1≤Li≤N-1) so that
Find Ri(1≤Ri≤N-1) so that
xLi≤ymin<xLi+1
xRi≤ymax<xRi+1
Dl(Li)=T[Li]+(Z[N]-Z[Li])
(22)
ER(Ri)=Z[Ri]+(T[N]-T[Ri])
(33)
Pl(Li)=V[Li]+(Y[N]-Y[Li])
(23)
QR(Ri)=Y[Ri]+(X[N]-X[Ri])
(34)
ymin=DLiPLi
(24)
ymax=ER(Ri)QR(Ri)
(35)
D=Dl(Li)
(25)
E=ERi
(36)
P=Pl(Li)
(26)
Q=QRi
(37)
k=Li.
(27)
k=Ri+1.
(38)
(4) Recursion:
Recursion:
αk=fk¯-fk_
(28)
αk=fk¯-fk_
(39)
D=D-xkαk
(29)
E=E-xkαk
(40)
P=P-αk
(30)
Q=Q-αk
(41)
yl=DP.
(31)
yr=EQ.
(42)
(5) If yl≤ymin, then ymin=yl, k=k-1 and go to step 4 else yL=ymin and stop.
If yR≥ymax, then ymax=cR and k=k+1 go to step 4 else yR=ymax and stop.
The initialization of IACS2 is characterized by its dependence from the inner-bound set. This feature introduces a big difference with previous algorithms since they use fixed initialization points (e.g., EKMA, IASC, and EIASC); however, regarding this particularity, IASC2 is similar to the KMA, because both algorithms include a FOU-dependent initialization.
The IASC2 works with the switch points starting inside the centroid, iterating similarly as IASC type algorithms but from the ymin toward left side while the minimum yL is reached, it is in the opposite sense to IASC and EIASC. The procedure for computing the maximum yR begins in ymax and goes to the right side until it is found, and the search direction is the same of IASC but opposite to the proposed in EIASC. The advantage of this initialization for computing the centroid is that always the switch points start close to the yL and yR; therefore, less iterations are used.
Figure 1 depicts a uniform random FOU with its yL,yR,ymin, or yl¯ and the ymax or yr_, and the arrows show the direction of the search of each procedure from the initial switch point to the minimum or maximum. Also, in this example, it is possible to see the space scanned by every algorithm, suggesting that this space is proportional to the amount of iterations required to converge. Note that IASC2 has the shortest arrows, which mean few iterations.
Uniform random FOU: fi¯ (red line) and fi_ (blue line). The arrows indicates the computation of minimum and maximum. Orange arrows correspond to IASC2, green to EIASC and blue to IASC.
In Table 1 (21), ymin corresponds to the minimum of the inner-bound set; thus according to (6) ymin≥yL. Therefore Table 1 (21) provides an initialization point that is always greater than or equal to the minimum extreme point yL; In addition, it is possible to find an integer Li so that xLi≤ymin<xLi+1. It is easy to show that Table 1 (22)–(24) is computing the left centroid function with k=Li, which fixes the starting point of recursion from the values obtained in the precomputation stage.
Recursion Table 1 (28)–(31) computes the left centroid function with initial point in k=Li, and each decrement in k leads to a decrement in yl(k). By doing some algebraic operations, it is easy to show that yl(k)=(∑i=1kxifi¯+∑i=k+1Nxifi_)/(∑i=1kfi¯+∑i=k+1Nfi_)=(DLi-∑i=k+1Lixi(fi¯-fi_))/(PLi-∑i=k+1Li(fi¯-fi_)). If sums are computed recursively, it leads to yl(k)=(Dk-1-xk(fk¯-fk_))/(Pk-1-(fk¯-fk_)).
Since L≤Li given that yl≤ymin in Table 1 (21), iterations should decrease k from Li. Thus, a decrement of k induces a decrement in fk from fk¯ to fk_. In [5], the following was demonstrated.
Condition 1.
If xk<y(f1⋯fN), then y(f1⋯fN) increases when fk decreases.
Condition 2.
If xk>y(f1⋯fN), then y(f1⋯fN) increases when fk increases.
Note that k is greater than L which implies that xk>yL; thus, it is guaranteed that xk>yl(k) satisfying Condition 1. Therefore, it can be concluded that a decrement in fk will induce a decrement in yl(k).
Finally, the stop condition is stated from the properties of the centroid function [13]. They indicate that the left-centroid function has a global minimum in k=L, so it is found when the functions start to increase.
The procedure to compute yL is only analyzed in this section. The full demonstration of this procedure is provided in the appendix for the readers who are interested in following it. The computation of yR obeys similar conceptual principles, and it can be understood by using the ideas suggested above or those provided in the appendix.
3.2. KMA2
The KM2 algorithm is presented in Table 2. This algorithm uses the same conceptual principles of KMA for finding yL and yR [5]. The algorithm includes precomputation, initialization, and searching loop. Precomputation and initialization of KMA2 are the same for IASC2, having always the initial switch points near to the extreme points yL and yR. The searching loop corresponds to steps 4–7. The core of the loop is Table 2 (53)–(55) and (A.2)–(A.4), which can be easily demonstrated by making Li equal to k or k′. These equations calculate yl(k) or yr(k) with few sums and subtractions taking advantage of pre-computed values. Finally, the stop condition is the same for the EKMA algorithm, which was stated in [16].
KMA2 algorithm flow.
KMA2
The KM algorithm for finding the minimum extreme point yL of the centroid of an interval type-2 fuzzy set over xi with upper membership function fi¯ and lower membership function fi_ can be restated as follows:
The KM algorithm for finding the maximum extreme point yR of the centroid of an interval type-2 fuzzy set over xi with upper membership function fi¯ and lower membership function fi_ can be reexpressed as follows:
(1) Sort xi(i=1,2,…,N) in ascending order and call the sorted xi by the same name, but now x1≤x2≤⋯≤xN. Match the weights fi with their respective xi and renumber them so that their index corresponds to the renumbered xi.
(2) Precomputation:
V[n]=∑i=1nfi¯ (43)
H[n]=∑i=1nfi_ (44)
T[n]=∑i=1nxifi¯ (45)
Z[n]=∑i=1nxifi_ (46)
with n=1,2,…N.
yA=T[N]V[N] (47)
yB=Z[N]H[N]. (48)
(3) Set
Set
ymin=min(yA,yB)
(49)
ymax=max(yA,yB)
(56)
Find k(1≤k≤N-1) so that
Find k(1≤k≤N-1) so that
xk≤ymin<xk+1
xk≤ymax<xk+1
Dl(k)=T[k]+(Z[N]-Z[k])
(50)
ER(k)=Z[k]+(T[N]-T[k])
(57)
Pl(k)=V[k]+(Y[N]-Y[k])
(51)
QR(k)=Y[k]+(X[N]-X[k])
(58)
y=Dl(k)Pl(k).
(52)
y=ER(k)QR(k).
(59)
(4) Find k′∈[1,N-1] such that
Find k′∈[1,N-1] such that
xk′≤y<xk′+1.
xk′≤y<xk′+1.
(5)
If k′=k, stop and set yL=y, else continue.
If k′=k, stop and set yR=y, else continue.
(6) Set
Set
Dl(k′)=T[k′]+(Z[N]-Z[k′])
(53)
ER(k′)=Z[k′]+(T[N]-T[k′])
(60)
Pl(k′)=V[k′]+(Y[N]-Y[k′])
(54)
QR(k′)=Y[k′]+(X[N]-X[k′])
(61)
y′=Dl(k′)Pl(k′).
(55)
y′=ER(k′)QR(k′).
(62)
(7) Set y=y′, k=k′ and go to step 4.
Set y=y′, k=k′ and go to step 4.
4. Computational Comparison with Existing Iterative Algorithms: Implementation Based on Compiled Language4.1. Simulation Setup
The purpose of these experiments is to measure the average computing time that a type-reduction algorithm takes to compute the interval centroid of a particular kind of FOU when the algorithm is implemented as a program in a compiled language like C. In addition, complementary variables like standard deviation of the computing time and the number of iterations required by each algorithm to converge are also registered. The algorithms considered in these experiments are IASC [14], EIASC [18], and EKMA [16], which are confronted against IASC2 and KMA2. For the sake of comparison, the EKM algorithm is regarded as a reference for all the experiments.
Four FOU cases were selected to evaluate the performance of the algorithms. All cases corresponded to random FOUs modified by different envelopes. The first one considered a constant envelope that simulated the output of a fuzzy inference engine in which most of the rules are fired at a similar level. In the second one, a centered envelope was used to simulate that rules with consequents in the middle region of the universe of discourse are fired. The last two cases were proposed to simulate firing rules whose consequents are in the outer regions of the universe of discourse. For the sake of clarity, several examples of the FOUs considered in this work are depicted in Figure 2.
FOUs cases used in the experiments. (a) Uniform random FOU. (b) Centered uniform random FOU. (c) Right-sided uniform random FOU. (d) Left-sided uniform random FOU.
The following experimental procedure was applied to characterize the performance of the algorithms over each FOU case described above: we increased N from 0 to 100 with step size of 10, and then N was increased from 100 to 1000 with step size of 100. For each N, 2000 Monte Carlo simulations were used to compute yL and yR. In order to overcome the problem of measuring very small times, 100.000 simulations were computed in each Monte Carlo trial; thus, the time of a type-reduction computation corresponded to the measured time divided by 100.000.
The algorithms were implemented as C programs and compiled as SCILAB functions. The experiments were carried out over SCILAB 5.3.1 numeric software running over a platform equipped with an AMD Athlon(tm) 64 × 2 Dual Core Processor 4000 + 2.10 GHz, 2 GB RAM, and Windows XP operating system.
4.1.1. Results: Computation Time
The results of computation time for uniform random FOUs are presented in Figure 3. IASC2 exhibited the best performance of all algorithms for N between 10 and 100. For N greater than 100, KMA2 was the fastest algorithm followed by IASC2. The percentage of computation time reduction (PCTR) with respect to the EKMA (i.e., PCTR=(to-tekm)/tekm where to and te are the average computation times of a particular algorithm and EKMA, resp.) of IASC2 was about 30% for N=10, while in the case of KMA2, the largest PCTR was about 40% for N=1000. Note that IASC and EIASC exhibited poorer performance with respect to EKMA when N grows beyond 100 points; however EIASC was the fastest algorithm for N=10 points. The standard deviation of the computation time for IASC2 and KMA2 was always smaller than that of the EKMA.
Uniform random FOU results (compiled language implementation of the algorithms). (a) Average computation time, (b) ratio with respect to the EKMA, and (c) standard deviation of the computation time.
Figure 4 presents the results for centered random FOUs. IASC2 exhibited the largest PCTR for N smaller than 100 points, about 40%. When Nwas greater than 100, KMA2 was the fastest algorithm. This algorithm provided a maximum PCTR of about 50% for N=1000. The standard deviation of the computation time for all algorithms was often smaller than that of EKMA.
Centered random FOU results (compiled language implementation of the algorithms). (a) Average computation time, (b) ratio with respect to the EKMA, and (c) standard deviation of the computation time.
In the case of left-sided random FOUs (Figure 5), IASC was the fastest algorithm for N smaller than 100 points. This algorithm provided a PCTR that was between 70% and 50%. Here again KMA2 was the fastest algorithm for N greater than 100 points with a PCTR that was about 45% for this region. In this case, EIASC exhibited the worst performance and, in general, the standard deviation of the computation time was similar for all the algorithms.
Left-sided random FOU results (compiled language implementation of the algorithms). (a) Average computation time, (b) ratio with respect to the EKMA, and (c) standard deviation of the computation time.
The results concerning right-sided random FOUs are presented in Figure 6. IASC2 was the algorithm that provided the largest PCTR for N smaller than 100 points. This percentage was between 55% and 60%. KMA2 accounted for the largest PCTR for N greater than 100 points. The reduction achieved by this algorithm was between 50% and 60%. IASC exhibited the worst performance in this case. The standard deviation of the computation time was similar in all algorithms for N smaller than 100; however, a big difference with respect to EKMA was observed for N greater than 100 points.
Right-sided random FOU results (compiled language implementation of the algorithms). (a) Average computation time, (b) ratio with respect to the EKMA, and (c) standard deviation of the computation time.
4.1.2. Results: Iterations
The amount of iterations required by each algorithm to find yR was recorded in all the experiments. In Figures 7–10, results for the mean of the number of iterations regarding each FOU case are presented. A comparison of the IASC-type algorithms and also of the KM-type algorithms are provided for discussion.
Uniform random FOU, iterations, (a) IASC-type algorithms and (b) KM-type algorithms.
Centered random FOU, iterations: (a) IASC-type algorithms and (b) KM-type algorithms.
Left-sided random FOU, iterations, (a) IASC-type algorithms and (b) KM-type algorithms.
Right-sided random FOU, iterations, (a) IASC-type algorithms and (b) KM-type algorithms.
In the case of a uniform random FOU (Figure 7), IASC2 reduced considerably the number of iterations when compared to the IASC and EIASC algorithms. The percentage reduction was about 75% for N=1000 with respect to EIASC. On the other hand, no improvement was observed for KMA2 over the EKMA in this case; however, the computation time was smaller for KMA2 as presented in previous subsection.
In the case of a centered random FOU, the IASC2 provided a significant reduction in the number of iterations compared to the IASC and EIASC algorithms, as shown in Figure 8. The percentage reduction was about 88% for N=1000 with respect to EIASC. Regarding the KM-type algorithms, the KMA2 reduced the number of iterations with respect to the EKMA for N smaller than 50 points. However, the performance of KMA2 is quite similar to that of EKMA for N greater than 100 points.
Regarding the results from the left-sided random FOU case (Figure 9), an interesting reduction in the number of iterations was achieved by IASC2 compared to the IASC and EIASC algorithms. The reduction percentage is around 90% for N=1000 with respect to EIASC. KMA2 displayed a reduction percentage ranging from 30% for N=1000 to 83% for N=10 with respect to EKMA.
The IASC2 algorithm outperformed the other two IASC-type algorithms for a right-sided random FOU (Figure 10), as observed in the previous cases. Considering the KM-type algorithms, KMA2 provided the largest reduction in the number of iterations with respect to EKMA for N=10 points. The reduction percentage was about 80% in this case. KMA2 also outperformed EKMA for greater resolutions.
4.2. Discussion
We believe that the four experiments reported in this section provide enough data to claim that IASC2 and KMA2 are faster than existing iterative algorithms like EKMA, IASC, and EIASC as long as the algorithms are coded as compiled language programs. The experiments are not only limited to one type of FOU, instead, typical FOU cases that are expected to be obtained at the aggregated output of an IT2-FLS were used. IASC2 may be regarded as the best solution for computing type-reduction in an IT2-FLS when the discretization of the output universe of discourse is smaller than 100 points. On the other hand, KMA2 might be the fastest solution when discretization is bigger than 100 points. Thus we believe that IASC2 should be used in real-time applications while KMA2 should be reserved for intensive applications.
Initialization based on the uncertainty bounds proved to be more effective than previous initialization schemes. This is evident from the reduction achieved in the number of iterations when finding yR (similar results were obtained in the case of yL). We argue that the inner-bound set is an initial point that adapts itself to the shape of the FOU. This is clearly different from the fixed initial points that pertain to EIASC and EKMA, where the uncertainty involved in the IT2-FS is not considered. In addition, a simple analysis of the uncertainty bounds in [7] shows that the inner-bound set largely contributes to the computation of the outer-bound set, which is used to estimate the interval centroid.
5. Computational Comparison with Existing Iterative Algorithms: Implementation Based on Interpreted Language5.1. Simulation Setup
The same four FOU cases of the previous section were used to characterize the algorithms implemented as interpreted programs. Since an interpreted implementation of an algorithm is slower than a compiled implementation, the experimental setup was modified. In this case, 2000 Monte Carlo trials were performed for each FOU case; however only 100 simulations were computed for each trial, so the time for executing a type-reduction is the measured time divided by 100.
The algorithms were implemented as SCILAB programs. The experiments were carried out over SCILAB 5.3.1 numeric software running over a platform equipped with an AMD Athlon(tm) 64 × 2 Dual Core Processor 4000 + 2.10 GHz, 2 GB RAM, and Windows XP operating system.
5.2. Results: Execution Time
The results of computation time for uniform random FOUs are presented in Figure 11. KMA2 achieved the best performance among all algorithms with a PCTR of around 60%, and the IASC2 PCTR was close to 50%. The standard deviation of the computation time for the IASC2 and KMA2 was always smaller than that of EKMA. Thus, considering an implementation using an interpreted language, KMA2 should be the most appropriated solution for type-reduction in an IT2-FLS.
Uniform random FOU results (interpreted language implementation of the algorithms). (a) Average computation time, (b) ratio with respect to the EKMA, and (c) standard deviation of computation time.
Figure 12 is similar to Figure 13. These figures present the results for centered random FOUs and left-sided random FOUs, respectively. KMA2 was the fastest algorithm, followed by IASC2, EIASC, IASC, and EKMA as the slowest. The IASC2 PCTR was almost similar to the KMA2 PCTR for N greater than 20, which was about 60%. When N=10, the IASC2 PCTR was about 46%. The standard deviation of computation time was similar for all algorithms for N smaller than 300 although it was significantly different with respect to the EKMA for N greater than 300 points.
Centered random FOU results (interpreted language implementation of the algorithms). (a) Average computation time, (b) ratio with respect to the EKMA, and (c) standard deviation of computation time.
Left-sided random FOU results (interpreted language implementation of the algorithms). (a) Average computation time, (b) ratio with respect to the EKMA, and (c) standard deviation of computation time.
The results with right-sided random FOUs in Figure 14 show that KMA2 was the fastest algorithm in all the cases, followed by IASC2 with a similar performance. The PCTR for N greater than 30 was about 76% with KMA2, while, with IASC2, it was about 74% over the EKMA computation time. For the other cases the reduction was around 70% and 64%, respectively. The standard deviation of the computation time for all algorithms was often smaller than that of EKMA.
Right-sided random FOU results (interpreted language implementation of the algorithms). (a) Average computation time, (b) ratio with respect to the EKMA, and (c) standard deviation of computation time.
6. Conclusions
Two new algorithms for computing the centroid of an IT2-FS have been presented, namely, IASC2 and KMA2. IASC2 follows the conceptual line of algorithms like IASC [14] and EIASC [18]. KMA2 is inspired in the KM and EKM algorithms [16]. The new algorithms include an initialization that is based on the concept of inner-bound set [7], which reduces the number of iterations to find the centroid of an IT2-FS. Moreover, precomputation is considered in order to reduce the computational burden of each iteration.
These features have led to motivating results over different kinds of FOUs. The new algorithms achieved interesting computation time reductions with respect to the EKM algorithm. In the case of a compiled-language-based implementation, IASC2 exhibited the best reduction for resolutions smaller than 100 points between 40% and 70%. On the other hand, KMA2 exhibited the best performance for resolutions greater than 100 points, resulting in a reduction ranging from 45% to 60%. In the case of an interpreted-language-based implementation, KMA2 was the fastest algorithm, exhibiting a computation time reduction of around 60%.
The implementation of IT2-FLSs can take advantage of the algorithms presented in this work. Since IASC2 reported the best results for low resolutions, we consider that this algorithm should be applied in real-time applications of IT2-FLSs. Conversely, KMA2 can be considered for intensive applications that demand high resolutions. The following step in this paper will be focused to compare the new algorithms IASC2 and KMA2 with the EODS algorithm, since it demonstrated to outperform EIASC in low-resolution applications [25].
Appendix
The proof of the algorithm IASC-2 for computing yL is divided in four parts.
It will be stated that Table 1 (21) fixes a valid initialization point.
It will be demonstrated that Table 1 (22)–(24) computes the left centroid function with k=Li.
It will be demonstrated that recursion of step 4 computes the left centroid function with initial point in k=Li, and each decrement in k leads to a decrement in yl(k).
The validity of the stop condition will be stated.
Proof.
(a) From Table 1 (15)–(21), it follows that
(A.1)yA=T[N]V[N]=∑i=1Nxifi¯∑i=1Nfi¯,(A.2)yB=Z[N]H[N]=∑i=1Nxifi_∑i=1Nfi_,(A.3)ymin=min(∑i=1Nxifi¯∑i=1Nfi¯,∑i=1Nxifi_∑i=1Nfi_),(A.4)ymin=yl¯.
It is clear that ymin in Table 1 (21) corresponds to the minimum of the inner-bound set [7], so according to (6) ymin≥yL. Thus Table 1 (21) provides an initialization point that is always greater than or equal to the minimum extreme point yL. In addition, It is possible to find an integer Li so that xLi≤ymin<xLi+1.
(b) From Table 1 (22), it follows that
(A.5)Dl(Li)=T[Li]+(Z[N]-Z[Li]),DLi=Dl(Li)=∑i=1Lixifi¯+(∑i=1Nxifi_-∑i=1Lixifi_),DLi=Dl(Li)=∑i=1Lixifi¯+∑i=Li+1Nxifi_.
From Table 1 (23), it follows that
(A.6)Pl(Li)=V[Li]+(Y[N]-Y[Li]),PLi=Pl(Li)=∑i=1Lifi¯+(∑i=1Nfi_-∑i=1Lifi_),PLi=Pl(Li)=∑i=1Lifi¯+∑i=Li+1Nfi_.
Therefore from Table 1 (24)
(A.7)ymin=DLiPLi=∑i=1Lixifi¯+(∑i=1Nxifi_-∑i=1Lixifi_)∑i=1Lifi¯+(∑i=1Nfi_-∑i=1Lifi_),ymin=∑i=1Lixifi¯+∑i=1Lixifi_+∑i=Li+1Nxifi_-∑i=1Lixifi_∑i=1Lifi¯+∑i=1Lifi_+∑i=Li+1Nfi_-∑i=1Lifi_,ymin=∑i=1Lixifi¯+∑i=Li+1Nxifi_∑i=1Lifi¯+∑i=Li+1Nfi_.
(c) First we show that recursion computes the left centroid function with initial point Li and decreasing k. Considering
(A.8)yl(k)=∑i=1kxifi¯+∑i=k+1Nxifi_∑i=1kfi¯+∑i=k+1Nfi_.
Expanding it without altering the proportion
(A.9)yl(k)=(∑i=1kxifi¯+∑i=k+1Nxifi_+∑i=k+1Lixifi¯-∑i=k+1Lixifi¯+∑i=k+1Lixifi_-∑i=k+1Lixifi_)×(∑i=1kfi¯+∑i=k+1Nfi_+∑i=k+1Lifi¯-∑i=k+1Lifi¯i+∑i=k+1Lifi_-∑i=k+1Lifi_)-1,yl(k)=∑i=1Lixifi¯+∑i=Li+1Nxifi_+∑i=k+1Lixifi_-∑i=k+1Lixifi¯∑i=1Lifi¯+∑i=Li+1Nfi_+∑i=k+1Lifi_-∑i=k+1Lifi¯,yl(k)=∑i=1Lixifi¯+∑i=Li+1Nxifi_-∑i=k+1Lixi(fi¯-fi_)∑i=1Lifi¯+∑i=Li+1Nfi_-∑i=k+1Li(fi¯-fi_),yl(k)=DLi-∑i=k+1Lixi(fi¯-fi_)PLi-∑i=k+1Li(fi¯-fi_),(A.10)yl(k)=DLi-∑i=k+1Lixi(fi¯-fi_)PLi-∑i=k+1Li(fi¯-fi_).
It can be observed that (A.10) is a proportion composed by initial values DLi and PLi and two terms that can be computed by recursion D(k) and P(k), so
(A.11)yl(k)=DLi-D(k)PLi-P(k),D(k)=∑i=k+1Lixi(fi¯-fi_),P(k)=∑i=k+1Li(fi¯-fi_).
Sums are computed by recursion as
(A.12)Dk-1=Dk-xk(fk¯-fk_),(A.13)Pk-1=Pk-(fk¯-fk_),(A.14)yl(k-1)=Dk-1Pk-1=Dk-xk(fk¯-fk_)Pk-(fk¯-fk_).
Since L≤Li given that yl≤ymin in Table 1 (21), iterations decrease k from Li according to (A.10).
It has been demonstrated that (A.14) is the same (A.8) computed recursively from initial point Li. So, by performing a decrement of k in step 5, a decrement is introduced in fi; that is,
(A.15)f=(f1,…,fN)=(f1¯,…fk-1¯,fk¯,fk+1_,…fN_),f=(f1,…,fN)=(f1¯,…fk-1¯,fk_,fk+1_,…fN_).
In [5], it is demonstrated that
(A.16)ifxk<y(f1,…,fN),theny(f1,…,fN)increaseswhenfkdecreases.(A.17)Ifxk>y(f1,…,fN),theny(f1,…,fN)increaseswhenfkincreases.
Note that k is greater than L which implies that xk>yL; thus from the centroid function properties, it is guaranteed that xk>yl(k), satisfying (A.17). Therefore, it can be concluded that a decrement in fk as (A.15) will induce a decrement in yl(k).
(d) The stop condition is stated from the properties of the centroid function. Since the centroid function has a global minimum in L, once recursion has reached k=L, yl(k) will increase in the next decrement of k because (A.17) is no longer valid. So by detecting the increment in yl(k), it can be said that the minimum has been found in the previous iteration.
Conflict of Interests
The authors hereby declare that they do not have any direct financial relation with the commercial identities mentioned in this paper.
MendelJ. M.Advances in type-2 fuzzy sets and systemsJohnR.CouplandS.Type-2 fuzzy logic: a historical viewMendelJ. M.Type-2 fuzzy sets and systems: an overviewCouplandS.JohnR.Geometric type-1 and type-2 fuzzy logic systemsMendelJ.MendelJ. M.On a 50% savings in the computation of the centroid of a symmetrical interval type-2 fuzzy setWuH.MendelJ. M.Uncertainty bounds and their use in the design of interval type-2 fuzzy logic systemsWuD.TanW. W.Computationally efficient type-reduction strategies for a type-2 fuzzy logic controllerProceedings of the IEEE International Conference on Fuzzy SystemsMay 20053533582-s2.0-23944446894YehC. Y.JengW. H. R.LeeS. J.An enhanced type-reduction algorithm for type-2 fuzzy setsWagnerC.HagrasH.Toward general type-2 fuzzy logic systems based on zSlicesMendelJ. M.LiuF.ZhaiD.α-Plane representation for type-2 fuzzy sets: theory and applicationsCouplandS.JohnR.An investigation into alternative methods for the defuzzification of an interval type-2 fuzzy setProceedings of the IEEE International Conference on Fuzzy SystemsJuly 2006142514322-s2.0-3425073118710.1109/FUZZY.2006.1681896MendelJ. M.LiuF.Super-exponential convergence of the Karnik-Mendel algorithms for computing the centroid of an interval type-2 fuzzy setDuranK.BernalH.MelgarejoM.Improved iterative algorithm for computing the generalized centroid of an interval type-2 fuzzy setProceedings of the Annual Meeting of the North American Fuzzy Information Processing Society (NAFIPS '08)May 2008New York, NY, USA2-s2.0-5114912077110.1109/NAFIPS.2008.4531244DuranK.BernalH.MelgarejoM.A comparative study between two algorithms for computing the generalized centroid of an interval Type-2 Fuzzy SetProceedings of the IEEE International Conference on Fuzzy SystemsJune 2008Hong Kong, China9549592-s2.0-5524908853010.1109/FUZZY.2008.4630484WuD.MendelJ. M.Enhanced Karnik-Mendel algorithmsLiuX.MendelJ. M.WuD.Study on enhanced Karnik-Mendel algorithms: Initialization explanations and computation improvementsWuD.NieM.Comparison and practical implementation of type-reduction algorithms for type-2 fuzzy sets and systemsProceedings of the IEEE International Conference on Fuzzy SystemsJune 201121312138MelgarejoM.A fast recursive method to compute the generalized centroid of an interval type-2 fuzzy setProceedings of the Annual Meeting of the North American Fuzzy Information Processing Society (NAFIPS '07)June 20071901942-s2.0-3514886775710.1109/NAFIPS.2007.383835SepúlvedaR.MontielO.CastilloO.MelinP.Embedding a high speed interval type-2 fuzzy controller for a real plant into an FPGASepúlvedaR.MontielO.CastilloO.MelinP.Modelling and simulation of the defuzzification stage of a type-2 fuzzy controller using VHDL codeMontielO.SepúlvedaR.MaldonadoY.CastilloO.Design and simulation of the type-2 fuzzification stage: using active membership functionsMaldonadoY.CastilloO.MelinP.Optimization of membership functions for an incremental fuzzy PD control based on genetic algorithmsLiC.YiJ.ZhaoD.A novel type-reduction method for interval type-2 fuzzy logic systemsProceedings of the 5th International Conference on Fuzzy Systems and Knowledge Discovery (FSKD '08)October 20081571612-s2.0-5814912505410.1109/FSKD.2008.173WuD.Approaches for reducing the computational cost of logic systems: overview and comparisonsHuH.WangY.CaiY.Advantages of the enhanced opposite direction searching algorithm for computing the centroid of an interval type-2 fuzzy setMendelJ. M.JohnR. I.LiuF.Interval type-2 fuzzy logic systems made simple