Keywords

These keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

1 Introduction

A type-2 fuzzy set (Fig. 1) (T2 FS) can be thought of as a fuzzy-fuzzy set. Its membership function (MF) no longer has a single value at each value of the primary variable, but instead is a blurred version of that function, i.e., at each value of the primary variable the membership is itself a function, called a secondary MF. When the secondary MF is a constant equal to 1, the T2 FS is called an interval type-2 fuzzy set (IT2 FS) or an interval-valued fuzzy set; otherwise, it is called a general type-2 fuzzy set (GT2 FS).

Fig. 1
figure 1

Components of a General type-2 fuzzy set

Full size image

The MF of a T2 FS is three-dimensional, with x-axis called the primary variable, y-axis called the secondary variable and z-axis called the MF value (or secondary grade). A vertical slice is a plane that is parallel to the MF-value z-axis. The footprint of uncertainty (FOU) of a T2 FS lies on the x-y plane and includes the closure of all points on that plane for which the MF value is non-zero; it is the 2D-domain on which sit the secondary grades. The FOU is lower and upper bounded by a lower membership function (LMF) and an upper membership function (UMF), both of which are type-1 fuzzy sets (T1 FSs). The FOU can be completely covered by T1 FSs that are called embedded T1 FSs.

T2 FSs are used in type-2 fuzzy logic systems (T2 FLSs) (Fig. 2). A general T2 FLS (GT2 FLS) was originally called a T2 FLS; however, because most of the works about T2 FLSs have focused on IT2 FSs, and only more recently on GT2 FSs, we now view the field of T2 FLSs as the union of the sub-fields of IT2 FLSs and GT2 FLSs.

Fig. 2
figure 2

Type-2 fuzzy logic system [23]. When all T2 FSs are IT2 FSs, the GT2 FLS becomes an IT2 FLS

Full size image

Practical applications of T2 FLSs (e.g., fuzzy logic control [26]) require a number at the output of the FLS and not a FS. Readers of this book know that for a T1 FLS such a number is obtained by a process called defuzzification, which can be interpreted as the projection of a T1 FS into a type-0 FS. Many kinds of defuzzifiers are possible, including center of gravity (centroid), height and center of sets.

So, how does one go from a T2 FS to a number? Nilesh Karnik and I struggled with how to do this for months and finally we came up with a two-stage approach [14, 23]: type-reduction (TR)—a new concept for FSs—followed by defuzzification.

TR projects a T2 FS into a T1 FS, after which that T1 FS is projected into a type-0-FS by defuzzification to obtain a number. Because a type-reduced set is a T1 FS, defuzzification is achieved by computing the centroid of that set. For an IT2 FLS the type-reduced set is an interval set whose center of gravity is the average value of its two end-points; so, defuzzification for an IT2 FLS is trivial.

Just as there can be different kinds of defuzzification methods for a T1 FLS, there can be different kinds of TR methods for a T2 FLS. It is generally agreed that all TR methods must satisfy Karnik and Mendel’s [23] fundamental design requirement for a T2 FLS, namely: When all sources of [membership function] uncertainty disappear, a T2 FLS must reduce to a comparable T1 FLS. This design requirement seems as reasonable today (in 2015) as it did to Karnik and Mendel in 2001, and is analogous to what happens to a probability density function when random uncertainties disappear. In that case, the variance of the pdf goes to zero, and a probability analysis reduces to a deterministic analysis. So, just as the capability for a deterministic analysis is embedded within a probability analysis, the capability for a T1 FLS is embedded within a T2 FLS.

As is stated in [25]: “TR became burned into the architecture of a T2 FLS because Karnik and Mendel first developed all of their T2 concepts and calculations for a general T2 FS and a GT2 FLS. Although TR was originally developed for a GT2 FLS, because it was so simple to perform for an IT2 FLS it was kept in the architecture of an IT2 FLS. There is nothing wrong with doing this; however, in retrospect we may have been blind-sided by the need for TR in a GT2 FLS from asking the question ‘Is TR really needed in an IT2 FLS?’

“In fact, there are many ways to go from an IT2 FLS to a number that bypass TR and still satisfy the fundamental design requirement.”

“A student in a class that I taught some years ago asked: ‘Instead of performing TR, why can’t we just use a combination of two T1 FLSs, one that uses only the lower membership functions and the other that uses only the upper membership functions?’ My answer at that time was: ‘You can’t do this because each end-point of the type-reduced set uses a mixture of lower and upper membership function information.’ While my answer was technically correct, it was predicated on using type-reduction, rather than on what the student had suggested. My answer today would be: ‘You can do what you are suggesting, and this can be done in different ways; however, by bypassing TR you may not be able to provide a measure of the uncertainties that have flowed through all of the IT2 FLS computations (analogous to a standard deviation).’ For example, you could begin with the architecture of an IT2 FLS as a linear combination of two T1 FLSs, as in [1], or as the centroid of the average of the lower and upper membership functions of the aggregated rule fired sets, as in [29]. All of these IT2 FLSs go directly to the defuzzified output value and they all satisfy the fundamental design requirement.”

Unfortunately, TR cannot be performed using a closed-form mathematical formula. Its calculations led to two simple iterative algorithms that have been and continue to be called KM-Algorithms (or Karnik-Mendel Algorithms) [14, 23]. Because the computational complexity of using GT2 FSs was so great in the late 1990s, until around 2008 we as well as all others focused on TR for IT2 FLSs. It is fair to say that all thinking about type-reduction was in the context of IT2 FLSs.

Karnik and Mendel’s two-step approach for going from a T2 FS to a number spawned a plethora of research and subsequent publications that fall into two categories: (1) type-reduction as an end to itself (i.e., TR viewed as a mathematical problem but with no application in mind, focusing on finding improved ways to perform TR); and, (2) direct defuzzification (i.e., methods for bypassing TR that project a T2 FS directly into a number). Unfortunately, some authors use the phrase “type-reduction” in the titles of papers that are about direct defuzzification, which is (in the opinion of this author) arguably incorrect.

Two journal articles that cover all aspects of this appeared in 2013, [24, 33]. The article by Wu [33] categorizes type-reduction and direct defuzzification algorithms into the following two categories:

  • Enhancements to the KM TR algorithms (W1) (these are about type-reduction) and

  • Alternative TR algorithms (W2) (these are almost all about direct defuzzification)

The article by Mendel [24] categorizes type-reduction algorithms into the following four categories:

  • Improved KM algorithms (M1) (these are about type-reduction)

  • Understanding the KM/EKM algorithms leading to further improved algorithms (M2) (these are about type-reduction)

  • Non-KM algorithms that preserve the ability to approximate the centroid or type-reduced set (M3) (these are about type-reduction), and,

  • Non-KM algorithms that do not preserve the ability to approximate the centroid or type-reduced set (M4) (these are about direct defuzzification)

While both articles contain a wealth of information about type-reduction and direct defuzzification algorithms, it requires a considerable effort by readers to relate an algorithm to its different categorizations across these two papers. In order to help with this, I will now classify the TR algorithms differently from both of these articles, as:

  • Algorithms that lead to a type-reduced set (Table 1)

    Table 1 Algorithms that lead to a type-reduced set
    Full size table

  • Algorithms that lead directly to a defuzzified value (Table 2)

    Table 2 Algorithms that lead directly to a defuzzified value
    Full size table

The connections between these two classes of algorithms and the classifications in [24, 33] are given in these tables.

2 Explanations of the Tables

Tables 1 and 2 organize the papers chronologically, so that one can see some sort of continuity in thought as time progresses. Unfortunately, no standards existed when these studies were performed (nor do they exist today, in 2015) for how to compare TR or direct defuzzification algorithms, so it is very difficult to draw statistically meaningful conclusions from the papers that are in these two tables. Most of the time the authors used different IT2 FSs (FOUs) (some of which are sampled versions of continuous FOUs), or randomly chosen samples for the LMFs and UMFs of discrete FOUs, or FOUs for which mathematical formulas are provided for their LMF and UMF.

Fortunately, [33] provides statistically meaningful comparisons for two kinds of FOUs: (1) randomly chosen samples for the LMFs and UMFs of discrete FOUs, and (2) evolutionary fuzzy logic controller design. If one is interested in which of the algorithms are the fastest or most accurate, then [33] is the paper to go to.

3 Critique of Type-Reduction as an End to Itself

Research on type-reduction as an end to itself, as summarized in Table 1, uses the (oft unstated) assumption that one begins with an IT2 FS to perform TR on. It then focuses on how to improve (or approximate) the KM Algorithms to perform type-reduction on that given IT2 FS. One or both of two performance measures are used to evaluate improvements: computing time and accuracy. All of this research (except for [30, 37]) is done outside of the original context of a T2 FLS, and is therefore open to some critical examinations.

For starters, the assumption that one begins with an IT2 FS to perform TR on needs to be questioned. I have explained in [24] that there are two distinctly different situations that can occur in an IT2 FLS:

  1. 1.

    Fired-rule IT2 FSs are first aggregated by means of the union operation resulting in an aggregated IT2 FS (so that the assumption is valid), after which this aggregated IT2 FS is type-reduced (this is called centroid type-reduction); and,

  2. 2.

    Fired-rule IT2 FSs are aggregated as part of type-reduction (this is called center-of sets type-reduction), in which case one does not begin with an aggregated IT2 FS, and so the assumption is invalid.

Obviously the people who are researching type-reduction as an end to itself are focusing on Situation 1; however, in real-world applications of FLSs it is Situation 2 that is more often used than Situation 1, because (this is also true for T1 FLSs) performing the aggregation of the fired-rule IT2 FSs is too time consuming. Consequently, research on type-reduction as an end to itself is about things that arguably will be of very little direct value or use in a T2 FLS.

One is then led to question whether or not the two metrics that are used in this kind of research for Situation 1 are important, namely computing time and accuracy.

Consider first the metric of computing time. If the results of this research are not going to be used in a real-time FLS then does it really matter if the algorithms that perform type-reduction take 10−3, 10−4, 10−5, etc. sec? KM or EKM [34] algorithms are already quite fast; they converge quadratically [19] and have been observed to take 10−5 to 10−3 s to converge (see, e.g., [34]). The EIASC algorithms [35] are even faster and they are very easy to understand. So, focusing on convergence time for Situation 1 is to me arguably a red herring because it makes no perceptual difference to a human when it is already quite small.

Consider next the metric of accuracy. To me an important question is: How much accuracy is required by the type-reduced set? Unfortunately, this question is never asked in the papers that use the metric of accuracy. Instead, one is left with an impression that higher accuracy is always better. Unless one knows what the type-reduced set will be used for then, I would like to ask: “What is higher accuracy better for?” To answer this question there are again two different situations/cases that need to be examined:

  • The LMF and UMF are given by mathematical formulas and so they can be sampled at any desired rate (C1), and

  • The LMF and UMF are given only by a collection of samples (C2).

Consider C1, in which the LMF and UMF are given by mathematical formulas, and so they can be sampled at any desired rate. Then KM algorithms will give very accurate results. To counter this some authors perform studies in which they reduce the sampling rate to see how more accurate their algorithms are than the KM algorithms. The Catch-22 to this work is that they are comparing the results from their algorithms and the KM algorithms both of which use the reduced sampled data with so-called true results, where the latter use the highly sampled data. To me this is circular reasoning, because if one has access to highly sampled data and is performing the type-reduction computations off-line then why not use all of the highly sampled data to perform the type-reduction?

Consider next C2 in which the LMF and UMF are given only by a collection of samples, as would occur if perchance fired rule output sets were aggregated by using the union (although, as explained above, this is usually avoided). The reason that the resulting aggregated IT2 FS is given only by a collection of samples is that it has been computed using an algorithm for the union that only uses sampled values. So, what exactly does accuracy mean in this situation? In this case the KM algorithms compute the true values of the type-reduced set and so they are 100 % accurate. To get around this fact, the authors pretend that they have access to the LMF and UMF given by mathematical formulas and have created a set of sampled values for the LMF and the UMF from those formulas. This throws us back to the previous case, but now that case is reached by violating the assumption that the LMF and UMF are given only by a collection of samples. This again is circular reasoning.

Regrettably, the conclusion I am led to about research on type-reduction as an end to itself is that it has led to results that are arguably of very little value.

4 Critique of Direct Defuzzification

All research on direct defuzzification should be applauded as long as the direct defuzzification method obeys the already-mentioned fundamental design requirement for a T2 FLS, namely: When all sources of [membership function] uncertainty disappear, a T2 FLS must reduce to a comparable T1 FLS. It should be applauded because its researchers have had the courage and conviction to challenge the need for type-reduction in an IT2 FLS. To me, this is how real progress occurs. These authors (although they may not have actually said it this way or at all) asked: “Why is type reduction needed in an IT2 FLS? Why can’t we go directly to a defuzzified output?”

As is demonstrated by the large number of papers in Table 2, there are many ways to go directly to a defuzzified output; however, many of the authors of direct defuzzification papers compare their numerical results with the ones obtained from using type-reduction followed by defuzzification, as though the latter was a baseline approach. So another natural question to ask is:

  • Should an IT2 FLS that uses type-reduction followed by defuzzification be the baseline IT2 FLS against which all others must be compared?

My answer to this question is “No,” and my reason is that maybe it should be the other way around, i.e. maybe an IT2 FLS that uses type-reduction followed by defuzzification should be compared against an IT2 FLS that uses direct defuzzification. This may sound like double talk or the chicken before the egg parable, but I am quite serious about my answer. Let me explain.

Real-world FLSs are designed with application-dependent performance specifications in mind. Unfortunately, authors (myself included) do not usually state what those specs are. Instead they assume that the goal is to optimize the performance metrics rather than meet those metrics, something that is not done in the business world.

Many years ago I attended a one-day seminar on entrepreneurship given by world-famous Peter Drucker. It just so happened that we were sitting at the same table for lunch. Everyone around the table introduced themselves. When it came to my turn and I told everyone that I was an engineer, Drucker shook his head. I asked him why he was doing that, to which he replied:

You engineers are always trying to optimize something, which is why you make such poor businessmen. A business person develops a product with a certain level of performance as quickly as possible, manufactures it, sells it and makes a profit. He or she then improves the product a bit and sells the next version, making even more profit. In the meantime, you engineers have not gotten off of the block; you are still trying to optimize your product, and have nothing to show for it.

So if an application’s performance metrics can be met by an IT2 FLS that uses direct defuzzification, that should be the end of the story. If, however, those performance metrics cannot be met by such an IT2 FLS then one could try either a different IT2 FLS that uses direct defuzzification, or, perhaps as a last resort, an IT2 FLS that uses type reduction followed by defuzzification. There is no a priori guarantee, however, that even the latter will be able to meet the performance metrics. If it cannot, then one may need to use a GT2 FLS.

5 Conclusions

Ever since Karnik and Mendel introduced the concept of type-reduction, which leads to solving two optimization problems, one for the left-end and one for the right end of the type-reduced set, a cottage industry has emerged that has focused on better ways to perform TR or to bypass it entirely. This paper has tried to provide a critical examination of the research that has been performed on these two topics.

It has explained that:

  1. 1.

    A good way to categorize type-reduction/direct defuzzification algorithm papers is, as: papers that focus on algorithms that lead to

    1. a.

      A type-reduced set, or

    2. b.

      Directly to a defuzzified value.

  2. 2.

    Research on type-reduction as an end to itself has led to results that are arguably of very little value.

  3. 3.

    The practice of base-lining an IT2 FLS that uses direct defuzzification against one that uses type-reduction followed by defuzzification is unnecessary.

Note that if Karnik and Mendel had never introduced type-reduction followed by defuzzification, and instead had achieved their design requirement by using direct defuzzification, then we would not be having this conversation, and people would be comparing results obtained by using one kind of direct defuzzification method against those obtained by using at least one other kind of direct defuzzification method.

As a final thought, note that type reduction was invented because Karnik and Mendel thought that the type-reduced set would itself be of value, in that it would provide a valuable measure of the flow of MF uncertainties through the FLS. Although it does do this, regrettably, to the best of knowledge of this author, there is not one application paper that makes use of the type-reduced set in this way. On the other hand, type-reduction did lead to the KM Algorithms (as well as others) which are very useful for solving other non-FLS problems, as is explained in [24].