An efficient non-iterative method for computing the centroid of an interval type-2 fuzzy set

Abstract

Interval type-2 fuzzy logic systems (IT2FLSs) have better abilities to cope with uncertainties in many applications. One major drawback of IT2FLSs is the high computational cost of the iterative Karnik-Mendel (KM) algorithms in type-reduction (TR). From the practical point of view, this prevents using IT2FLS in real-world applications. To address this issue, a novel non-iterative method called Moradi-Zirkohi-Lin (MZL) TR method is proposed for computing the centroid of an IT2FLS. This makes the practical implementation of the IT2FLSs simpler. Comparative simulation results show that the proposed method outperforms the KM TR method in terms of computational burden. Besides, closer results, in terms of accuracy, to the KM TR method among the existing non-iterative TR methods are also achieved by the proposed TR method.

Keywords

Karnik-Mendel (KM) algorithms type-reduction non-iterative the centroid of an interval type-2 Fuzzy Set

1 Introduction

Type-2 fuzzy sets (T2FSs) were first put forth by Zadeh in 1975 [1]. The membership functions (MFs) in a T2FS are themselves a type-1 fuzzy set (T1FS) instead of crisp numbers in a T1FS. This is the main difference between a T2FS and a T1FS. Therefore, the MF of a T2FS is three dimensional. This enhances the performance of the T2FSs over T1FSs in the face of the uncertainties. The better ability of T2FSs in handling various uncertainties has gained significant attention in numerous applications [2, 3]. The structure of an IT2FLS is similar to its T1FLS counterpart, the main difference is that at least one of the FSs in the rule base is an IT2FS. The outputs of the inference engine are therefore IT2FSs, and before defuzzification can be performed, a type-reduction (TR) block is required to convert them into a T1FS [4, 5]. However, the computational burden of the TR block is a major problem which confines the applications of IT2FLSs. So far, to address this problem many iterative approaches for computing type reduction for IT2FSs have been provided [6]. The Karnik-Mendel (KM) algorithms are the most popular procedures used in IT2FLSs for computing type reduction [7]. It has been established that the KM algorithms are super exponentially fast [8]. However, the KM TR method is an iterative method which needs several iterations to converge. There exists no closed form solutions to this problem. This requires a considerable amount of computation time [7]. However, regarding complexity, the KM TR method is not the state-of-the-art TR method. In [9], it has been shown that the enhanced opposite direction searching (EODS) algorithms are among the most rapid algorithms for practical IT2FLSs. The EODS has also been extended for computing the centroid TR of general type-2 fuzzy logic systems [10]. To make the practical implementation of the IT2FLSs simpler, much research has been devoted to providing non-iterative methods for computing the centroid of an IT2FLS. In [11], two defuzzification methods using interval-valued FSs are proposed. In [12], an unnormalized TR method is proposed. The uncertainty bound (UB) method can also be considered as a famous non-iterative method [13]. In [14], another closed-form TR and defuzzification method called Begian-Melek-Mendel (BMM) algorithms have been proposed. In [15], a novel type-reduction approach has been proposed according to interval analysis. In [16], the Nagar-Bardini (NB) method as an effective non-iterative method has been put forth. In [17], a comparison is made between some non-iterative algorithms.

1.1 Novelties and Contribution

Considering the TR methods mentioned above, most of the non-iterative TR methods have their own problems [9]. The computing result produced in most of the existing non-iterative TR methods is actually a compromise between accuracy and computation time. The accuracy sometimes sacrifices to get less computation time. Motivated from the mentioned papers, the main contribution of this paper is to develop a new simple non-iterative TR method to be used in the IT2FLSs. The aim of the proposed TR method is not only to reduce the computational burden, but also to ensure accuracy. The proposed approach is quite simple and can pave the way for the practical implementation of IT2FLSs.

The organization of the rest of the paper is as follows. Problem formulation is presented in Section 2. The proposed method is given in Section 3. Simulation results are given in Section 4. Finally, conclusion remarks are given in Section 5.

2 Problem formulation

The following problem is frequently met in (but not limited to) fuzzy logic theory [18]:

Given $x_{i} \in X_{i} \equiv [{\underline{x}}_{i}, {\bar{x}}_{i}], i = 1, 2, \dots, N$ (1) $w_{i} \in W_{i} \equiv [{\underline{w}}_{i}, {\bar{w}}_{i}], i = 1, 2, \dots, N$ (2)where ${\underline{x}}_{i}, \leq {\bar{x}}_{i}, i = 1, 2, \dots, N$ (3) ${\underline{w}}_{i}, \leq {\bar{w}}_{i}, i = 1, 2, \dots, N$ (4) where ${\underline{x}}_{i}$ and ${\bar{x}}_{i}$ are the lower and the upper bounds of the interval sets considered for the consequent part of i^th. rule of the fuzzy system; ${\underline{w}}_{i}$ . and ${\bar{w}}_{i}$ . are the lower and upper bounds of the firing of i^th. rule of the IT2FLS and N is the number of the rules of the IT2FLS.

compute $Y = \frac{\sum_{i = 1}^{N} X_{i} W_{i}}{\sum_{i = 1}^{N} W_{i}} = [y_{l}, y_{r}]$ (5)

where $y_{l} = min_{\begin{matrix} \forall x_{i} ɛ [{\underline{x}}_{i}, {\bar{x}}_{i}] \\ \forall w_{i} ɛ [{\underline{w}}_{i}, {\bar{w}}_{i}] \end{matrix}} \frac{\sum_{i = 1}^{N} x_{i} w_{i}}{\sum_{i = 1}^{N} w_{i}}$ (6) $y_{r} = max_{\begin{matrix} \forall x_{i} ɛ [{\underline{x}}_{i}, {\bar{x}}_{i}] \\ \forall w_{i} ɛ [{\underline{w}}_{i}, {\bar{w}}_{i}] \end{matrix}} \frac{\sum_{i = 1}^{N} x_{i} w_{i}}{\sum_{i = 1}^{N} w_{i}}$ (7)

It is well known that y_l. and y_r in (5) and (6) can be expressed as [19] $y_{l} = \frac{\sum_{i = 1}^{L} {\underline{x}}_{i} {\bar{w}}_{i} + \sum_{i = L + 1}^{N} {\underline{x}}_{i} {\underline{w}}_{i}}{\sum_{i = 1}^{L} {\bar{w}}_{i} + \sum_{i = L + 1}^{N} {\underline{w}}_{i}}$ (8) $y_{r} = \frac{\sum_{i = 1}^{R} {\bar{x}}_{i} {\underline{w}}_{i} + \sum_{i = R + 1}^{N} {\bar{x}}_{i} {\bar{w}}_{i}}{\sum_{i = 1}^{R} {\underline{w}}_{i} + \sum_{i = R + 1}^{N} {\bar{w}}_{i}}$ (9) where L and R are the switch points and Karnik–Mendel (KM) algorithms or enhanced KM (EKM) algorithms [7, 18] can be used to compute them iteratively, which is computationally intensive.

Now, after computing y_l. and y_r, the defuzzified output can be computed as: $y = \frac{y_{l} + y_{r}}{2}$ (10)

In the sequel, some of the well-known algorithms for computing the defuzzified output are reviewed [18].

2.1 The KM algorithms

The well-known iterative KM algorithms are given as follows:

KM for computing y_l :.

1) Sort ${\underline{x}}_{i} (i = 1, 2, 3, . ., N)$ . in increasing order and call the sorted ${\underline{x}}_{i}$ . by the same name. Match the weights w_i with their respective ${\underline{x}}_{i}$ . and renumber them so that their index corresponds to the renumbered ${\underline{x}}_{i}$ ..

2) Initialize w_i. by setting $w_{i} = \frac{{\underline{w}}_{i} + {\bar{w}}_{i}}{2}, i = 1, 2, \dots, N$ (11)

And then computing $y = \frac{\sum_{i = 1}^{N} {\underline{x}}_{i} w_{i}}{\sum_{i = 1}^{N} w_{i}} .$ (12)

3) Find switch point k (1 ⩽ k ⩽ N - 1) such that ${\underline{x}}_{k} ⩽ y ⩽ {\underline{x}}_{k + 1}$ (13)

4) Set $w_{i} = {\begin{matrix} \begin{matrix} {\bar{w}}_{i} & if i ⩽ k \end{matrix} \\ {\underline{w}}_{i} if i > k \end{matrix}$ (14)

and compute $y^{'} = \frac{\sum_{i = 1}^{N} {\underline{x}}_{i} w_{i}}{\sum_{i = 1}^{N} w_{i}} .$ (15)

5) Check if y′ = y .. If yes, stop, set y_l = y, and set L = k. If no, go to step 6.

6) Set y = y′, and go to step 3

KM for computing y_r :.

1) Sort ${\bar{x}}_{i} (i = 1, 2, 3, . ., N)$ . in increasing order and call the sorted ${\bar{x}}_{i}$ by the same name. Match the weights w_i with their respective ${\bar{x}}_{i}$ and renumber them so that their index corresponds to the renumbered ${\bar{x}}_{i}$ .

2) Initialize w_i by setting $w_{i} = \frac{{\underline{w}}_{i} + {\bar{w}}_{i}}{2}, i = 1, 2, \dots, N$ (16)

and then computing $y = \frac{\sum_{i = 1}^{N} {\bar{x}}_{i} w_{i}}{\sum_{i = 1}^{N} w_{i}}$ (17)

3) Find switch point k (1 ⩽ k ⩽ N - 1) such that ${\bar{x}}_{k} ⩽ y ⩽ {\bar{x}}_{k + 1}$ (18)

4) Set $w_{i} = {\begin{matrix} \begin{matrix} {\underline{w}}_{i} & ifi ⩽ k \end{matrix} \\ {\bar{w}}_{i} ifi > k \end{matrix}$ (19)

and compute $y^{'} = \frac{\sum_{i = 1}^{N} {\bar{x}}_{i} w_{i}}{\sum_{i = 1}^{N} w_{i}}$ (20)

5) Check if y′ = y . If yes, stop, set y_r = y, and set R = k. If no, go to step 6.

6) Set y = y′ . and go to step 3.

Now, it next section some non-iterative algorithms are reviewed.

2.2 Uncertainty Bounds (UB)

First, thd points y_l and y_r are bounded as [13]: ${\underline{y}}_{l} ⩽ y_{l} ⩽ {\bar{y}}_{l}, {\underline{y}}_{r} ⩽ y_{r} ⩽ {\bar{y}}_{r}$ (21) where ${\bar{y}}_{l} = \min {\frac{\sum_{i = 1}^{N} {\underline{x}}_{i} {\underline{w}}_{i}}{\sum_{i = 1}^{N} {\underline{w}}_{i}}, \frac{\sum_{i = 1}^{N} {\underline{x}}_{i} {\bar{w}}_{i}}{\sum_{i = 1}^{N} {\bar{w}}_{i}}}$ (22) ${\underline{y}}_{r} = \max {\frac{\sum_{i = 1}^{N} {\bar{x}}_{i} {\underline{w}}_{i}}{\sum_{i = 1}^{N} {\underline{w}}_{i}}, \frac{\sum_{i = 1}^{N} {\bar{x}}_{i} {\bar{w}}_{i}}{\sum_{i = 1}^{N} {\bar{w}}_{i}}}$ (23)

Then

$\begin{matrix} {\underline{y}}_{l} = {\bar{y}}_{l} - [\frac{\sum_{i = 1}^{N} ({\bar{w}}_{i} - {\underline{w}}_{i})}{\sum_{i = 1}^{N} {\bar{w}}_{i} \sum_{i = 1}^{N} {\underline{w}}_{i}} \\ \times \frac{\sum_{i = 1}^{N} {\underline{w}}_{i} ({\underline{x}}_{i} - {\underline{x}}_{1}) \sum_{i = 1}^{N} {\bar{w}}_{i} ({\underline{x}}_{N} - {\underline{x}}_{i})}{\sum_{i = 1}^{N} {\underline{w}}_{i} ({\underline{x}}_{i} - {\underline{x}}_{1}) + \sum_{i = 1}^{N} {\bar{w}}_{i} ({\underline{x}}_{N} - {\underline{x}}_{i})}] \end{matrix}$ (24)

$\begin{matrix} {\bar{y}}_{r} = {\underline{y}}_{r} + [\frac{\sum_{i = 1}^{N} ({\bar{w}}_{i} - {\underline{w}}_{i})}{\sum_{i = 1}^{N} {\bar{w}}_{i} \sum_{i = 1}^{N} {\underline{w}}_{i}} \\ \times \frac{\sum_{i = 1}^{N} {\bar{w}}_{i} ({\bar{x}}_{i} - {\bar{x}}_{1}) \sum_{i = 1}^{N} {\underline{w}}_{i} ({\bar{x}}_{N} - {\bar{x}}_{i})}{\sum_{i = 1}^{N} {\bar{w}}_{i} ({\bar{x}}_{i} - {\bar{x}}_{1}) + \sum_{i = 1}^{N} {\underline{w}}_{i} ({\bar{x}}_{N} - {\bar{x}}_{i})}] \end{matrix}$ (25)

Observe that the four bounds in (22)-(25) can be computed without having to perform TR. Finally, the output can be computed as $y = \frac{1}{2} [\frac{{\underline{y}}_{l} + {\bar{y}}_{l}}{2} + \frac{{\underline{y}}_{r} + {\bar{y}}_{r}}{2}]$ (26)

2.3 The Begian-Melek-Mendel (BMM) Method

In [14], another closed form TR and defuzzification method for IT2 FLSs has been proposed as follows: $y = α \frac{\sum_{i = 1}^{N} x_{i} {\underline{w}}_{i}}{\sum_{i = 1}^{N} {\underline{w}}_{i}} + β \frac{\sum_{i = 1}^{N} x_{i} {\bar{w}}_{i}}{\sum_{i = 1}^{N} {\bar{w}}_{i}}$ (27) where α and β are adjustable coefficients. The BMM method does not require x_i to be sorted.

2.4 The Li-Yi-Zhao (LYZ) Method

In [15], a new TR method has been proposed as follows:

$\begin{matrix} y_{l} = \min [\frac{\sum_{i = 1}^{N} min ({\underline{w}}_{i} {\underline{x}}_{i}, {\bar{w}}_{i} {\underline{x}}_{i})}{\sum_{i = 1}^{N} {\underline{w}}_{i}}, \\ \frac{\sum_{i = 1}^{N} min ({\underline{w}}_{i} {\underline{x}}_{i}, {\bar{w}}_{i} {\underline{x}}_{i})}{\sum_{i = 1}^{N} {\bar{w}}_{i}}] \end{matrix}$ (28)

$\begin{matrix} y_{r} = \max [\frac{\sum_{i = 1}^{N} min ({\underline{w}}_{i} {\bar{x}}_{i}, {\bar{w}}_{i} {\bar{x}}_{i})}{\sum_{i = 1}^{N} {\underline{w}}_{i}}, \\ \frac{\sum_{i = 1}^{N} min ({\underline{w}}_{i} {\bar{x}}_{i}, {\bar{w}}_{i} {\bar{x}}_{i})}{\sum_{i = 1}^{N} {\bar{w}}_{i}}] \end{matrix}$ (29) $y = \frac{y_{l} + y_{r}}{2}$ (30)

The LYZ method does not require x_i to be sorted.

2.5 The Nagar-Bardini (NB) Method

In [16], a new TR method has been proposed as follows: $y_{l} = \frac{\sum_{i = 1}^{N} x_{i} {\underline{w}}_{i}}{\sum_{i = 1}^{N} {\underline{w}}_{i}}$ (31) $y_{r} = \frac{\sum_{i = 1}^{N} x_{i} {\bar{w}}_{i}}{\sum_{i = 1}^{N} {\bar{w}}_{i}}$ (32) $y = \frac{y_{l} + y_{r}}{2}$ (33)

The NB method does not require x_i to be sorted. This method is similar to BMM method.

3 Proposed method

This section presents an efficient non-iterative method called Moradi-Zirkohi-Lin (MZL) algorithms to compute the center of IT2FLS.

MZL for computing y_l :

1) First compute $w_{avg} = \frac{\sum_{i = 1}^{N} {\bar{w}}_{i} + \sum_{i = 1}^{N} {\underline{w}}_{i}}{2}$ (34)

2) Compute ${\underline{p}}_{i} = {\begin{matrix} \begin{matrix} {\underline{x}}_{i} & if {\underline{x}}_{i} > 0 \end{matrix} \\ 0 if {\underline{x}}_{i} ⩽ 0 \end{matrix}$ (35) ${\underline{q}}_{i} = {\begin{matrix} \begin{matrix} {\underline{x}}_{i} & if {\underline{x}}_{i} < 0 \end{matrix} \\ 0 if {\underline{x}}_{i} ⩾ 0 \end{matrix}$ (36)

Match the weights w_i with their respective ${\underline{x}}_{i}$ . This means that ${\underline{b}}_{i} = {\begin{matrix} \begin{matrix} {\underline{w}}_{i} & if {\underline{x}}_{i} > 0 \end{matrix} \\ 0 if {\underline{x}}_{i} ⩽ 0 \end{matrix}$ (37) ${\bar{b}}_{i} = {\begin{matrix} \begin{matrix} {\bar{w}}_{i} & if {\underline{x}}_{i} > 0 \end{matrix} \\ 0 if {\underline{x}}_{i} ⩽ 0 \end{matrix}$ (38) ${\underline{h}}_{i} = {\begin{matrix} \begin{matrix} {\underline{w}}_{i} & if {\underline{x}}_{i} < 0 \end{matrix} \\ 0 if {\underline{x}}_{i} ⩾ 0 \end{matrix}$ (39) ${\bar{h}}_{i} = {\begin{matrix} \begin{matrix} {\bar{w}}_{i} & if {\underline{x}}_{i} < 0 \end{matrix} \\ 0 if {\underline{x}}_{i} ⩾ 0 \end{matrix}$ (40)

3) Compute $A = [\begin{matrix} A_{1} & A_{2} \end{matrix}] = [\begin{matrix} \sum_{i = 1}^{N} {\underline{p}}_{i} {\underline{b}}_{i} & \sum_{i = 1}^{N} {\underline{p}}_{i} \end{matrix} {\bar{b}}_{i}]$ (41) $B = [\begin{matrix} B_{1} & B_{2} \end{matrix}] = [\begin{matrix} \sum_{i = 1}^{N} {\underline{q}}_{i} {\underline{h}}_{i} & \sum_{i = 1}^{N} {\underline{q}}_{i} \end{matrix} {\bar{h}}_{i}]$ (42)

4) Compute all possible combinations $A = [\begin{matrix} A_{1} + B_{1} & A_{1} + B_{2} & \begin{matrix} A_{2} + B_{1} & A_{2} + B_{2} \end{matrix} \end{matrix}]$ (43)

5) Compute $y_{1}^{'} = \frac{\min (A)}{w_{avg}}$ (44) $y_{2}^{'} = \frac{\max (A)}{w_{avg}}$ (45)

6) Compute $y_{l} = \frac{y_{1}^{'} + y_{2}^{'}}{2}$ (46)

MZL for computing y_r :

1) First compute $w_{avg} = \frac{\sum_{i = 1}^{N} {\bar{w}}_{i} + \sum_{i = 1}^{N} {\underline{w}}_{i}}{2}$ (47)

2) Compute ${\bar{p}}_{i} = {\begin{matrix} \begin{matrix} {\bar{x}}_{i} & if {\bar{x}}_{i} > 0 \end{matrix} \\ 0 if {\bar{x}}_{i} ⩽ 0 \end{matrix}$ (48) ${\bar{q}}_{i} = {\begin{matrix} \begin{matrix} {\bar{x}}_{i} & if {\bar{x}}_{i} < 0 \end{matrix} \\ 0 if {\bar{x}}_{i} ⩾ 0 \end{matrix}$ (49)

Match the weights w_i with their respective ${\bar{x}}_{i}$ . This means that ${\underline{b}}_{i} = {\begin{matrix} \begin{matrix} {\underline{w}}_{i} & if {\bar{x}}_{i} > 0 \end{matrix} \\ 0 if {\bar{x}}_{i} ⩽ 0 \end{matrix}$ (50) ${\bar{b}}_{i} = {\begin{matrix} \begin{matrix} {\bar{w}}_{i} & if {\bar{x}}_{i} > 0 \end{matrix} \\ 0 if {\bar{x}}_{i} ⩽ 0 \end{matrix}$ (51) ${\underline{h}}_{i} = {\begin{matrix} \begin{matrix} {\underline{w}}_{i} & if {\bar{x}}_{i} < 0 \end{matrix} \\ 0 if {\bar{x}}_{i} ⩾ 0 \end{matrix}$ (52) ${\bar{h}}_{i} = {\begin{matrix} \begin{matrix} {\bar{w}}_{i} & if {\bar{x}}_{i} < 0 \end{matrix} \\ 0 if {\bar{x}}_{i} ⩾ 0 \end{matrix}$ (53)

3) Compute $A = [\begin{matrix} A_{1} & A_{2} \end{matrix}] = [\begin{matrix} \sum_{i = 1}^{N} {\bar{p}}_{i} {\underline{b}}_{i} & \sum_{i = 1}^{N} {\bar{p}}_{i} \end{matrix} {\bar{b}}_{i}]$ (54) $B = [\begin{matrix} B_{1} & B_{2} \end{matrix}] = [\begin{matrix} \sum_{i = 1}^{N} {\bar{q}}_{i} {\underline{h}}_{i} & \sum_{i = 1}^{N} {\bar{q}}_{i} \end{matrix} {\bar{h}}_{i}]$ (55)

4) Compute all possible combinations $A = [\begin{matrix} A_{1} + B_{1} & A_{1} + B_{2} & \begin{matrix} A_{2} + B_{1} & A_{2} + B_{2} \end{matrix} \end{matrix}]$ (56)

5) Compute $y_{1}^{'} = \frac{\min (A)}{w_{avg}}$ (57) $y_{2}^{'} = \frac{\max (A)}{w_{avg}}$ (58)

6) Compute $y_{r} = \frac{y_{1}^{'} + y_{2}^{'}}{2}$ (59)

Finally, the output can be computed as $y = \frac{y_{l} + y_{r}}{2}$ (60)

Note that unlike the KM TR method, the MZL TR method does not require x_i to be sorted

4 Simulation results

In this section, the performance of the proposed type-reduction algorithms are compared with the existing algorithms. In the simulations, for each N, N pairs of ${{\underline{x}}_{i}, {\bar{x}}_{i}}$ are generated by using Matlab function 2*rand(N,1)-1, and N pairs of ${{\underline{w}}_{i}, {\bar{w}}_{i}}$ are also generated by using Matlab function rand(N,2), where ${\underline{w}}_{i} ⩽ {\bar{w}}_{i}$ . Note that ${\underline{w}}_{i}$ and ${\bar{w}}_{i}$ are constrained in [0, 1], and ${\underline{x}}_{i}$ . ’s are independent of ${\underline{w}}_{i}$ . and ${\bar{w}}_{i}$ . The results are given in Table 1. In BMM TR method α. and β are both set to 0.5. To have a better comparison, a bar chart of the data reported in is also shown in Fig. 1. As seen, the MZL TR method achieves results close to those reported by the KM TR method. It should be noted that the MZL TR method can be considered as a simplified version of uncertainty bounds TR method. However, compared to the UB TR method, the proposed MZL TR method does not require to identify the lowest and highest values of y_l and y_r. Further, the results obtained are much better than the UB TR method. It can also be noted that the proposed MZL TR method is also similar to the LYZ TR method. However, the results are much better than those reported with the LYZ TR method. To highlight the advantages of the proposed MZL TR method, three special and challenging cases are also investigated.

Table 1
Comparative Results

N Output using KM Output using BMM Output using LYZ Output using UB Output using NB Output using MZL

3 –0.0028 –0.0034 –0.0056 0.1327 –0.0034 –0.0035

5 –0.0045 –0.0048 –0.0064 –0.0111 –0.0048 –0.0043

10 –0.0013 –0.0000001 –0.0020 0.0173 –0.0000001 –0.0010

100 0.0017 0.0023 0.0025 0.0053 0.0023 0.0021

1000 0.0010 0.00015 0.0016 0.0298 0.00015 0.0015

10000 0.0031 0.0034 0.0050 –0.0145 0.0034 0.0031

N	Output using KM	Output using BMM	Output using LYZ	Output using UB	Output using NB	Output using MZL
3	–0.0028	–0.0034	–0.0056	0.1327	–0.0034	–0.0035
5	–0.0045	–0.0048	–0.0064	–0.0111	–0.0048	–0.0043
10	–0.0013	–0.0000001	–0.0020	0.0173	–0.0000001	–0.0010
100	0.0017	0.0023	0.0025	0.0053	0.0023	0.0021
1000	0.0010	0.00015	0.0016	0.0298	0.00015	0.0015
10000	0.0031	0.0034	0.0050	–0.0145	0.0034	0.0031

Fig. 1

Bar chart showing the comparative results.

Case 1. In this case, a simple fuzzy system is considered as an example, where only two rules are fired [9]. The rules are given in Table 2. The results reported using different TR methods are given in Table 3. As shown in Table 3, difference between MZL TR method and the LYZ TR method is huge. It can be concluded that when $\sum_{i = 1}^{N} {\underline{w}}_{i}$ approaches zero, the LYZ TR method does not give good results. In addition, the computation time of the MZL TR method and the LYZ TR method are similar to each other. However, the MZL TR method gives better result. Among them, the BMM TR method has a less computation time; however, as confirmed in the BMM TR method results are far from the KM TR method. Therefore, the superiority of the MZL TR method in terms of accuracy, and computation time among the existing non-iterative TR methods is evident.

Table 2

Simple fuzzy system (Case 1)

Rule No.	Firing Interval	Consequent
R¹	${{\underline{w}}_{1}, {\bar{w}}_{1}} = [0.001, 0.2]$	[0.5, 0.6]
R²	${{\underline{w}}_{2}, {\bar{w}}_{2}} = [0, 0.8]$	[0.9, 1]

Table 3

Comparative results (Case 1)

The KM Method		The NB Method		The LYZ Method		The MZL Method
Output	Computation time (Sec.)	Output	Computation time (Sec.)	Output	Computation time (Sec.)	Output	Computation time (Sec.)
0.7498	0.084	0.7100	0.036	460	0.069	0.8098	0.070

Case 2. In this case, another simple fuzzy system is considered as an example, in which only four rules are fired [20]. Table 4 demonstrates the rules. The results reported using different TR methods are given in Table 5. As seen, the difference between the proposed MZL TR method and KM TR method is very small. In addition, the computation time of the MZL TR method and the LYZ TR method is similar to each other. However, the MZL TR method gives better results. Among them, the BMM TR method has less computation time; however, as already confirmed in Table 1 the BMM TR method results are far from the KM TR method. Therefore, it is again confirmed that the proposed MZL TR method can be considered as an efficient TR method for practical applications

Table 4

Simple fuzzy system (Case 2)

Rule No.	Firing Interval	Consequent
R¹	${{\underline{w}}_{1}, {\bar{w}}_{1}} = [0, 0.405]$	[- 1, - 0.9]
R²	${{\underline{w}}_{2}, {\bar{w}}_{2}} = [0.22, 0.9]$	[- 0.6, - 0.4]
R³	${{\underline{w}}_{3}, {\bar{w}}_{3}} = [0, 0.27]$	[0.4, 0.6]
R⁴	${{\underline{w}}_{4}, {\bar{w}}_{4}} = [0.055, 0.6]$ .	[0.9, 1]

Table 5

Comparative Results (Case 2)

The KM Method		The BMM Method		The LYZ Method		The MZL Method
Output	Computation time (Sec.)	Output	Computation time (Sec.)	Output	Computation time (Sec.)	Output	Computation time (Sec.)
–0.0463	0.0618	–0.1348	0.0249	–0.4027	0.0424	–0.0765	0.0496

Case 3. In this case, an interval type-2 fuzzy logic controller (IT2FLC) is developed to be used in the first-order lag plant. The transfer function of the plant is given as $G (s) = \frac{e^{(- . 01 s)}}{1 + 10 s}$ (61)

To construct the IT2FLC, the error (e = y - y_d) and its derivative $\dot{e}$ are considered as inputs of the IT2FLC. In the meantime,y is the output of the system to be controlled, and y_d is the desired output. It is assumed that y_d = 1. In addition, u is considered as the output of the IT2FLC that acts as input of the system to be controlled. According to Fig. 2, for each input three membership functions are selected. Therefore, the whole control space is covered with 9 rules as given in Table. 6. The scaling factors for e, $\dot{e}$ and u are selected as 0.8,.08, and 4, respectively. The control surfaces of the designed IT2FLC with KM TR method, LYZ TR method, and MZL TR method are shown in Fig. 3 and Fig. 4, respectively. In these figures x₁ = e and $x_{2} = \dot{e}$ . As seen, the control surface of the IT2FLC with the KM TR method and the MZL TR method are similar to each other. Therefore, it can be expected that they provide same performance. As already mentioned, when $\sum_{i = 1}^{N} {\underline{w}}_{i}$ approaches zero, the LYZ TR method does not give good results. This issues is again confirmed in Fig. 3. The output of the control system using different TR methods is shown in Fig. 5. As seen, the control performance using all of the methods are satisfactory. It should be highlighted that KM and MZL type-reduction approaches have similar performance.

Table 6

Fuzzy rules (Case 3)

$\dot{e}$	N	Z	P
P	0.25	0.75	1
N	–0.5	$150 e + 10 \dot{e}$	+0.5
Z	–1	–0.75	–0.25

Fig. 2

The membership functions for eand $\dot{e}$ (Case 3).

Fig. 3

Control surface computed by KM and LYZ TR method (Case 3).

Fig. 4

Control surface computed by MZL TR method (Case 3).

Fig. 5

The performance of the control system (Case 3).

Case 4. In this case, three IT2FSs are adopted from [21], and are given in Table. 7. It is assumed that that the FOUs and corresponding secondary MFs of centroid output IT2FSs have been known by aggregating or weighting the firing rules under the guidance of inference. For the first example, piecewise linear MFs are considered. For the second example, the FOU includes piecewise linear functions and Gaussian functions. For the third example, the FOU includes the Gaussian functions. To have a better comparison, the mean relative error (MRE) is defined as: $| \frac{c_{i} - c_{i}^{*}}{c_{i}^{*}} | (i = 1, 2, 3)$ . In which $c_{i}^{*}$ is the defuzzified value (DV) using KM TR method, and c_i is the defuzzified value using the other methods. Table. 8 presents computation results for these examples using different sampling points. To have a better comparison, a bar chart of the data reported in Table. 8 is also shown in Fig. 6. As seen, the proposed MZL TR method can provide the smallest MRE, whereas the LYZ TR method provides the largest MRE. After the MZL TR method, the NB TR method is also provided good results. As a conclusion, the MZL TR method can obtain the best accuracy compared to the others.

Table 7

IT2 FS Examples (Case 4)

Table 8

Computation Results (Case 4)

IT2 FS	N	KM	LYZ		UB		NB		MZL
DV	DV	MRE	DV	MRE	DV	MRE	DV	MRE
${\tilde{A}}_{1}$	100	4.3263	6.1129	41%	2.8745	33%	4.3051	0.49%	4.3209	0.12%
	500	4.3261	6.1129	41%	2.6822	38%	4.3050	0.48%	4.3208	0.12%
	1000	4.3261	6.1128	41%	2.6548	38%	4.3050	0.48%	4.3208	0.12%
	5000	4.3261	6.1128	41%	2.6322	39%	4.3050	0.48%	4.3208	0.12%
${\tilde{A}}_{2}$	100	3.7819	12.3057	225%	3.9866	5.4%	3.7665	0.4%	3.7684	0.35%
	500	3.7951	12.3054	224%	3.9944	5.25%	3.7752	0.52%	3.7854	0.25%
	1000	3.7968	12.3056	224%	3.9954	5.23%	3.7763	0.54%	3.7873	0.25%
	5000	3.7981	12.3058	224%	3.9962	5.21%	3.7771	0.55%	3.7883	0.25%
${\tilde{A}}_{3}$	100	4.3494	6.4072	46%	4.7163	8%	4.3278	0.49%	4.3307	0.42%
	500	4.3513	6.4078	47%	4.7045	8%	4.3293	0.5%	4.3328	0.42%
	1000	4.3515	6.4079	47%	4.7031	8%	4.3296	0.51%	4.3330	0.42%
	5000	4.3517	6.4078	47%	4.7020	8%	4.3297	0.5%	4.3333	0.42%

Now, since the computation time is a major factor for real-time applications, the computation time for the mentioned algorithms is also investigated. As observed in, the best results was obtained using the MZL and NB TR methods. Therefore, in what follows, just the computation time of these TR methods are compared with KM TR method. Computation time results are depend upon the hardware and software environments. In the paper, the simulations are carried out by a PC with i3-3220 CPU@3.3GHz and 8.00 GB memory, Windows 10 operation system, and Matlab 2015b. Each of the TR methods is run 1000 times for N = 10; 20; ... ; 5000 sampled values of the three IT2FSs that are given in Table. 7. Then average is calculated for 1000 computation times. Computation time comparisons for ${\tilde{A}}_{1}$ , ${\tilde{A}}_{2}$ , and ${\tilde{A}}_{3}$ are shown in Fig. 7, Fig. 8, Fig. 9, respectively. From these figures, it can be observed that both of the NB and MZL TR methods are faster that the KM TR method. It is interesting to note that the NB TR method is faster than MZL TR Method. However, the results presented in Table. 8 reveal that the MZL TR method provide the smallest MRE compared to the NB TR method.

Fig. 6

Bar chat showing computation time comparisons (Case 4).

Fig. 7

Computation time comparisons for ${\tilde{A}}_{1}$ (Case 4).

Fig. 8

Computation time comparisons for ${\tilde{A}}_{2}$ (Case 4).

Fig. 9

Computation time comparisons for ${\tilde{A}}_{3}$ (Case 4).

As a conclusion, from the results presented in Table 1, Table 3, Table 5 and Table. 8, the major advantages of the proposed MZL TR method are summarized as follows:

The MZL TR method outperforms the LYZ TR method when $\sum_{i = 1}^{N} {\underline{w}}_{i}$ approaches zero. In this case the LYZ TR method does not give good results. However, as confirmed in Table 3, in this case the results of the MZL TR method are quite satisfactory.

Unlike the KM TR method, in the MZL TR method, there is no need to sort x_i.

Unlike the UB TR method, the MZL TR method does not require the bounds of y_r and y_l to be calculated.

The computation time of the MZL TR method is less than that of the KM TR method.

Since the BMM TR method and UB TR method are approximations of the KM TR method, they have not provided the same results as the KM TR method, as expected.

The MZL TR method can be considered as an excellent approximation method.

The NB TR method is faster than the MZL TR Method, whereas the results presented in Table. 8 reveal that the MZL TR method provide the smallest MRE compared to the NB TR method.

The MZL TR method is a promising TR method and can be effectively used in implementing IT2FLSs.

5 Conclusion

To reduce the computational burden, an efficient non-iterive TR method for computing the centroid of IT2FLSs has been presented. The presented method (the MZL TR method) is very simple. Comparative simulation results have been presented to confirm the efficiently of the proposed TR method. It can be concluded that the MZL TR method is an approximation of LYZ TR method which is an approximation of KM TR method. In addition, from the view of computational complexity, the proposed MZL TR method is much more efficient than the LYZ TR method, the NB TR method, and the UB TR method for practical implementations.

Footnotes

Acknowledgments

The first author gratefully appreciates the support of the Behbahan Khatam Alanbia University of Technology. This work was supported in part by the Ministry of Science and Technology, Taiwan, R.O.C., under Grant MOST 109-2221-E-035-015-.

References

Dubois

and Prade

, Fuzzy sets in approximate reasoning, Part 1: Inference with possibility distributions, Fuzzy Sets and Systems 40(1) (1991), 143–202.

Hamza

M.F.

, Yap

H.J.

, Choudhury

I.A.

, Chiroma

and Kumbasar

, A survey on advancement of hybrid type 2 fuzzy sliding mode control, Neural Computing and Applications (2017), pp. 1–23.

Qin

, A survey of type-2 fuzzy aggregation and application for multiple criteria decision making, Journal of Data, Information and Management 1(1) (2019), 17–32.

, Two differences between interval type-2 and type-1 fuzzy logic controllers: Adaptiveness and novelty, Advances in Type-2 Fuzzy Sets and Systems, (2013), pp. 33–48: Springer.

Mendel

J.M.

, Type-2 fuzzy sets, Uncertain Rule-Based Fuzzy Systems, (2017), pp. 259–306: Springer.

Torshizi

A.D.

, Zarandi

M.H.F.

and Zakeri

, On type-reduction of type-2 fuzzy sets: A review, Applied Soft Computing 27 (2015), 614–627.

Karnik

N.N.

and Mendel

J.M.

, Centroid of a type-2 fuzzy set, Information Sciences 132(1-4) (2001), 195–220.

Mendel

J.M.

and Liu

, Super-exponential convergence of the Karnik–Mendel algorithms for computing the centroid of an interval type-2 fuzzy set, IEEE Transactions on Fuzzy Systems 15(2) (2007), 309–320.

, Approaches for reducing the computational cost of interval type-2 fuzzy logic systems: overview and comparisons, IEEE Transactions on Fuzzy Systems 21(1) (2013), 80–99.

10.

Chen

, Study on centroid type-reduction of general type-2 fuzzy logic systems with enhanced opposite direction searching algorithms, Int J Innov Comput Inf Control 15(4) (2019), 1425–1439.

11.

Gorzal-czany

M.B.

, Interval-valued fuzzy controller based on verbal model of object, Fuzzy Sets and Systems 28(1) (1988), 45–53.

12.

Liang

and Mendel

J.M.

, Equalization of nonlinear time-varying channels using type-2 fuzzy adaptive filters, IEEE Transactions on Fuzzy Systems 8(5) (2000), 551–563.

13.

and Mendel

J.M.

, Uncertainty bounds and their use in the design of interval type-2 fuzzy logic systems, IEEE Transactions on fuzzy systems 10(5) (2002), 622–639.

14.

Begian

M.B.

, Melek

W.W.

and Mendel

J.M.

, Stability analysis of type-2 fuzzy systems, in Fuzzy Systems, 2008. FUZZ-IEEE 2008. (IEEE World Congress on Computational Intelligence). IEEE International Conference on, 2008, pp. 947–953.

15.

, Yi

and Zhao

, A novel type-reduction method for interval type-2 fuzzy logic systems, in Fuzzy Systems and Knowledge Discovery, 2008. FSKD’08. Fifth International Conference on, 2008 Fifth International Conference on Fuzzy Systems and Knowledge Discovery, 2008, pp. 157–161.

16.

El-Nagar

A.M.

and El-Bardini

, Simplified interval type-2 fuzzy logic system based on new type-reduction, Journal of Intelligent & Fuzzy Systems 27(4) (2014), 1999–2010.

17.

Chen

, Study on Centroid Type-Reduction of Interval Type-2 Fuzzy Logic Systems Based on Noniterative Algorithms, Complexity 2019 (2019), pp. 7325053, 2019/04/11.

18.

and Mendel

J.M.

, Enhanced karnik–mendel algorithms, IEEE Transactions on Fuzzy Systems 17(4) (2009), 923–934.

19.

Mendel

J.M.

, Uncertain rule-based fuzzy logic systems: introduction and new directions: Prentice Hall PTR Upper Saddle River, 2001.

20.

, A brief Tutorial on Interval type-2 fuzzy sets and systems, Fuzzy Sets and Systems 4(1) (2010), 220–225.

21.

Mendel

J.M.

and Liu

, Simplified interval type-2 fuzzy logic systems, IEEE Transactions on Fuzzy Systems 21(6) (2013), 1056–1069.