[ed.: This article was posted to comp.ai.fuzzy and sci.engr.control on
 Tue, 19 Jan 1993 02:50:26 GMT]

This is the second part in a three-part series of introductory articles on
the fuzzy field.  The preceding article was titled "What is Fuzzy Logic?",
and the next article will be titled "What is Fuzzy Control?".

One point I didn't make in my previous article, "What is Fuzzy Logic", is that
in practice, the terms fuzzy subset and membership function get used nearly 
interchangeably.  I'll probably slip up and swap back and forth some - my
apologies in advance.


What is a Fuzzy Expert System?
------------------------------

Put as simply as possible, a fuzzy expert system is an expert system that uses
fuzzy logic instead of Boolean logic.  In other words, a fuzzy expert system is 
a collection of membership functions and rules that are used to reason about 
data.  Unlike conventional expert systems, which are mainly symbolic reasoning 
engines, fuzzy expert systems are oriented toward numerical processing.

The rules in a fuzzy expert system are usually of a form similar to the
following:

    if x is low and y is high then z = medium

where x and y are input variables (names for know data values), z is an output 
variable (a name for a data value to be computed), low is a membership function
(fuzzy subset) defined on x, high is a membership function defined on y, and
medium is a membership function defined on z.  The part of the rule between
the "if" and "then" is the rule's _premise_ or _antecedent_.  This is a fuzzy
logic expression that describes to what degree the rule is applicable.  The
part of the rule following the "then" is the rule's _conclusion_ or 
_consequent_.  This part of the rule assigns a membership function to each of
one or more output variables.  Most tools for working with fuzzy expert systems
allow more than one conclusion per rule.

A typical fuzzy expert system has more than one rule.  The entire group of 
rules is collectively known as a _rulebase_ or _knowledge base_.

The Inference Process
---------------------

With the definition of the rules and membership functions in hand, we now need
to know how to apply this knowledge to specific values of the input variables
to compute the values of the output variables.  This process is referred to
as _inferencing_.  In a fuzzy expert system, the inference process is a 
combination of four subprocesses: _fuzzification_, _inference_, _composition_, 
and _defuzzification_.  The defuzzification subprocess is optional.

For the sake of example in the following discussion, assume that the variables
x, y, and z all take on values in the interval [ 0, 10 ], and that we have the
following membership functions and rules defined.

  low(t)  = 1 - t / 10
  high(t) = t / 10

  rule 1: if x is low and y is low then z is high
  rule 2: if x is low and y is high then z is low
  rule 3: if x is high and y is low then z is low
  rule 4: if x is high and y is high then z is high

Notice that instead of assigning a single value to the output variable z, each
rule assigns an entire fuzzy subset (low or high).

Notes:

1. In this example, low(t)+high(t)=1.0 for all t.  This is not required, but 
   it is fairly common.

2. The value of t at which low(t) is maximum is the same as the value of t at
   which high(t) is minimum, and vice-versa.  This is also not required, but
   fairly common.

3. The same membership functions are used for all variables.  This isn't
   required, and is also *not* common.

  Fuzzification
  -------------

  In the fuzzification subprocess, the membership functions defined on the 
  input variables are applied to their actual values, to determine the degree
  of truth for each rule premise.  The degree of truth for a rule's premise
  is sometimes referred to as its _alpha_.  If a rule's premise has a nonzero
  degree of truth (if the rule applies at all...) then the rule is said to
  _fire_.

  For example:

x	y	low(x)	high(x)	low(y)	high(y)	alpha1	alpha2	alpha3	alpha4
------------------------------------------------------------------------------
0.0	0.0	1.0	0.0	1.0	0.0	1.0	0.0	0.0	0.0
0.0	3.2	1.0	0.0	0.68	0.32	0.68	0.32	0.0	0.0
0.0	6.1	1.0	0.0	0.39	0.61	0.39	0.61	0.0	0.0
0.0	10.0	1.0	0.0	0.0	1.0	0.0	1.0	0.0	0.0
3.2	0.0	0.68	0.32	1.0	0.0	0.68	0.0	0.32	0.0
6.1	0.0	0.39	0.61	1.0	0.0	0.39	0.0	0.61	0.0
10.0	0.0	0.0	1.0	1.0	0.0	0.0	0.0	1.0	0.0
3.2	3.1	0.68	0.32	0.69	0.31	0.68	0.31	0.32	0.32
3.2	3.3	0.68	0.32	0.67	0.33	0.67	0.33	0.32	0.32
10.0	10.0	0.0	1.0	0.0	1.0	0.0	0.0	0.0	1.0

  Inference
  ---------

  In the inference subprocess, the truth value for the premise of each rule is
  computed, and applied to the conclusion part of each rule.  This results in
  one fuzzy subset to be assigned to each output variable for each rule.

  I've only seen two _inference methods_ or _inference rules_: _MIN_ and 
  _PRODUCT_.  In MIN inferencing, the output membership function is clipped off 
  at a height corresponding to the rule premise's computed degree of truth.  
  This corresponds to the traditional interpretation of the fuzzy logic AND
  operation.  In PRODUCT inferencing, the output membership function is scaled
  by the rule premise's computed degree of truth.

  Due to the limitations of posting this as raw ASCII, I can't draw you a
  decent diagram of the results of these methods.  Therefore I'll give the
  example results in the same functional notation I used for the membership
  functions above.

  For example, let's look at rule 1 for x = 0.0 and y = 3.2.  As shown in the
  table above, the premise degree of truth works out to 0.68.  For this rule, 
  MIN inferencing will assign z the fuzzy subset defined by the membership
  function:

    rule1(z) = { z / 10, if z <= 6.8
                 0.68,   if z >= 6.8 }

  For the same conditions, PRODUCT inferencing will assign z the fuzzy subset
  defined by the membership function:

    rule1(z) = 0.68 * high(z)
             = 0.068 * z

  Note: I'm using slightly nonstandard terminology here.  In most texts, the
  term "inference method" is used to mean the combination of the things I'm
  referring to separately here as "inference" and "composition."  Therefore,
  you'll see terms such as "MAX-MIN inference" and "SUM-PRODUCT inference" in
  the literature.  They mean the combination of MAX composition and MIN 
  inference, or SUM composition and PRODUCT inference respectively, to use my
  terminology.  You'll also see the reverse terms "MIN-MAX" and "PRODUCT-SUM" -
  these mean the same things as the reverse order.  I think it's clearer to 
  describe the two processes separately.

  Composition
  -----------

  In the composition subprocess, all of the fuzzy subsets assigned to each
  output variable are combined together to form a single fuzzy subset for each
  output variable.

  I'm familiar with two _composition rules_: _MAX composition_ and _SUM 
  composition_.  In MAX composition, the combined output fuzzy subset is
  constructed by taking the pointwise maximum over all of the fuzzy subsets
  assigned to the output variable by the inference rule.  In SUM composition,
  the combined output fuzzy subset is constructed by taking the pointwise
  sum over all of the fuzzy subsets assigned to the output variable by the
  inference rule.  Note that this can result in truth values greater than
  one!  For this reason, SUM composition is only used when it will be followed
  by a defuzzification method, such as the CENTROID method, that doesn't have
  a problem with this odd case.

  For example, assume x = 0.0 and y = 3.2.  MIN inferencing would assign the
  following four fuzzy subsets to z:

      rule1(z) = { z / 10,     if z <= 6.8
                   0.68,       if z >= 6.8 }

      rule2(z) = { 0.32,       if z <= 6.8
                   1 - z / 10, if z >= 6.8 }

      rule3(z) = 0.0

      rule4(z) = 0.0

  MAX composition would result in the fuzzy subset:

      fuzzy(z) = { 0.32,       if z <= 3.2
                   z / 10,     if 3.2 <= z <= 6.8
                   0.68,       if z >= 6.8 }


  PRODUCT inferencing would assign the following four fuzzy subsets to z:

      rule1(z) = 0.068 * z
      rule2(z) = 0.32 - 0.032 * z
      rule3(z) = 0.0
      rule4(z) = 0.0

  SUM composition would result in the fuzzy subset:

      fuzzy(z) = 0.32 + 0.036 * z

  Defuzzification
  ---------------

  Sometimes it is useful to just examine the fuzzy subsets that are the result 
  of the composition process, but more often, this _fuzzy value_ needs to be 
  converted to a single number - a _crisp value_.  This is what the 
  defuzzification subprocess does.

  There are more defuzzification methods than you can shake a stick at.  A 
  couple of years ago, Mizumoto did a short paper that compared roughly thirty 
  defuzzification methods.  Two of the more common techniques are the CENTROID 
  and MAXIMUM methods.  In the CENTROID method, the crisp value of the output 
  variable is computed by finding the variable value of the center of gravity 
  of the membership function for the fuzzy value.  In the MAXIMUM method, one
  of the variable values at which the fuzzy subset has its maximum truth value
  is chosen as the crisp value for the output variable.  There are several
  variations of the MAXIMUM method that differ only in what they do when there
  is more than one variable value at which this maximum truth value occurs.
  One of these, the AVERAGE-OF-MAXIMA method, returns the average of the
  variable values at which the maximum truth value occurs.

  For example, go back to our previous examples.  Using MAX-MIN inferencing
  and AVERAGE-OF-MAXIMA defuzzification results in a crisp value of 8.4 for z.
  Using PRODUCT-SUM inferencing and CENTROID defuzzification results in a
  crisp value of 5.6 for z.

  Note: sometimes the composition and defuzzification processes are combined,
  taking advantage of mathematical relationships that simplify the process of
  computing the final output variable values.

After all this ...

Where are Fuzzy Expert Systems Used?
------------------------------------

To date, fuzzy expert systems are the most common use of fuzzy logic.  They
are used in several wide-ranging fields, including:

o Linear and nonlinear control.
o Pattern recognition.
o Financial systems.

and many others I can't think of.  It's late.  I'm going home! :-)
--
Copyright (c) Togai InfraLogic, 1993.  All rights reserved.
Permission to freely distribute this document, provided that it remains
complete and intact, is hereby granted.
