Q1. What is Hybridization? What is the Basic Objective of this Approach?

Describe Its
Characteristics.

Hybridization:
Hybridization, in the context of soft computing, refers to the integration of multiple soft
computing techniques to form a unified system capable of solving complex and uncertain
problems. “Hybridization can necessarily be made only if it provides a better method to arrive
at a solution or it may become an alternative method of solution to the problem under
consideration.”
Objective of the Hybridization Approach:
● The basic objective of hybridization is to combine the strengths of different soft
computing methods while minimizing their weaknesses.
● “The basic requirement of the hybridization process is that the hybrid model should
highlight the strengths of the constituent models and hide the weaknesses as far as
practicable.”
● Hybrid models aim to provide alternative or superior solutions, especially in cases
involving imprecision, uncertainty, vagueness, and incomplete information, which
are common in real-world applications.
● Another important objective is to address the limitations of individual models, such as:
○ High training time in neural networks,
○ Lack of adaptability in fuzzy systems,
○ The discrete nature of rough sets,
○ Inflexibility of classical optimization algorithms.
Characteristics of Hybridization:
● The main characteristics of hybridization in soft computing are:e main characteristics of
hybridization in soft computing are:
○ Enhances Problem-Solving Ability: The combined model is capable of solving more
complex problems than any individual model alone. For example, rough fuzzy sets,
fuzzy neural networks, and rough intuitionistic fuzzy sets have been developed to
address sophisticated tasks.
○ Integration of Strengths: Several successful hybrid models have been developed. Some of
these are fuzzy neural networks, fuzzy rough sets, rough fuzzy sets, intuitionistic fuzzy
rough sets, rough intuitionistic fuzzy sets. These models combine the reasoning ability
of fuzzy logic, the data-driven learning of neural networks, and the granularity of
rough sets.
○ Overcomes Weaknesses of Individual Models: The goal is to create a balanced and
optimized solution.
○ Flexibility in Design: Hybridization can occur in various forms:
● In a cooperative system, one technique (e.g., neural networks) helps determine
parameters for another (e.g., fuzzy inference system).
 ● In concurrent systems, both methods work together simultaneously.
● In fused systems, the components are fully integrated and share parameters and
data structures.
○ Applicability to a Wide Range of Domains: Hybrid systems like the Rough
Intuitionistic Fuzzy C-Means (RIFCM) algorithm have shown better performance in
clustering tasks compared to their non-hybrid counterparts.

2. What are the different approaches to hybridization? Explain them in detail.

Hybridization in soft computing refers to the integration of different computational methods,

each having their own strengths and weaknesses. While these techniques work well individually
in specific domains, combining them can potentially offer a more powerful solution. However,
hybridization must be carried out thoughtfully. If done improperly, it may end up carrying over
the weaknesses of the individual techniques instead of leveraging their strengths.

There are three approaches to hybridization:

1. Sequential Hybridization – In this approach, the initial input is provided to the first
method, and its output is passed on to the next method. This continues until the final
method produces the solution. The methods operate in a pipeline, where each one’s
output becomes the next one’s input.

2. Auxiliary Hybridization – Here, the second method is used during the processing of
the input by the first method. It acts like a function call, assisting the main method and
passing the processed result back.

3. Integrated Hybridization – This form involves a tighter coupling where multiple

techniques are combined as a unified system.

The goal of all approaches is to develop improved or alternative solutions that are more effective
than using individual methods alone.

3. Write a short note on fuzzy neural networks.

Fuzzy Neural Networks (FNNs) are hybrid systems that combine fuzzy logic with artificial
neural networks (ANNs). They are particularly suitable for applications involving uncertainty
and imprecision, such as classification and pattern recognition.

While classical neural networks can be used for similar purposes, FNNs offer several distinct
features:

● They use fuzzy inputs and outputs, allowing the system to handle vague and imprecise
 data more effectively.

● Inputs are mapped into fuzzy membership values rather than crisp numerical values.

● The outputs of these systems are fuzzy sets that represent degrees of truth, enhancing
interpretability.

● Weights in the network determine the degree of influence one neuron has on another,
similar to traditional neural networks, but adapted to accommodate fuzzy reasoning.

FNNs often work with fuzzy rules and fuzzy equivalence classes to capture relationships
among data points. This makes them more human-like in decision-making compared to purely
data-driven models.

Overall, FNNs leverage the learning ability of neural networks and the linguistic, rule-based
reasoning of fuzzy logic, making them powerful tools in soft computing.

4. Define fuzzy equivalence relations and provide an example. Compute the fuzzy
equivalence classes.

Definition:

A fuzzy equivalence relation is a fuzzy relation S on a universe U, defined on U×U, that

satisfies three fundamental properties:\

Example:

Let the universe be: U = {a, b, c}

Fuzzy Relation Matrix:

Define a fuzzy relation S on U × U with the following membership values:

a b c

a 1.0 0.8 0.6

b 0.8 1.0 0.6

c 0.6 0.6 1.0

Step-by-Step Property Check:

1. Reflexivity: All diagonal elements are 1.0 → Reflexivity is satisfied.

2. Symmetry: S(a,b)=0.8 = S(b,a), S(a,c)=0.6 = S(c,a), S(b,c)=0.6 = S(c,b) → Symmetry is

satisfied.

3. Transitivity: Check min{S(x,y), S(y,z)} ≤ S(x,z). For example:

- For a → b → c: min{S(a,b), S(b,c)} = min{0.8, 0.6} = 0.6, and S(a,c) = 0.6 → OK

- For b → c → a: min{S(b,c), S(c,a)} = min{0.6, 0.6} = 0.6, and S(b,a) = 0.8 → OK

→ Transitivity is satisfied in all combinations.

Hence, S is a valid fuzzy equivalence relation.

Fuzzy Equivalence Classes:

[a]_S = { (a, 1.0), (b, 0.8), (c, 0.6) }

[b]_S = { (a, 0.8), (b, 1.0), (c, 0.6) }

[c]_S = { (a, 0.6), (b, 0.6), (c, 1.0) }

These classes indicate how similar other elements are to a, b, and c based on the fuzzy relation S.

5. Define fuzzy rough sets. Under what circumstances this concept reduces to rough sets or
fuzzy sets?

Fuzzy rough sets are a hybrid model that combines the principles of fuzzy set theory and rough
set theory to manage uncertainty, vagueness, and incomplete information. As described in the
document, fuzzy rough sets extend rough sets by incorporating a fuzzy equivalence relation S
defined on the universe U. The relation S is a fuzzy set on U × U that satisfies three conditions:

1. Fuzzy Reflexivity: μ_S(x, x) = 1 x U

2. Fuzzy Symmetry: μ_S(x, y) = μ_S(y, x)

3. Fuzzy Transitivity: μ_S(x, z) ≥ min{μ_S(x, y), μ_S(y, z)}

Using this relation, fuzzy equivalence classes [x] are constructed.

For a fuzzy subset X ⊆ U, the fuzzy rough set is described by its lower
and upper approximations:

Lower approximation:

μ_L(x) = inf_{y U} max{1 - μ_S(x, y), μ_X(y)}

Upper approximation:

μ_U(x) = sup_{y U} min{μ_S(x, y), μ_X(y)}

Reduction to Rough Sets or Fuzzy Sets:

According to the text, when the fuzzy relation S becomes a crisp equivalence relation, i.e., only
values 0 or 1, the model reduces to a classical rough set.

On the other hand, if all fuzzy equivalence classes become singletons (i.e., μ_S(x, y) = 1 only
when x = y), the approximations match the fuzzy membership function:

μ_L(x) = μ_U(x) = μ_X(x)

In this case, the fuzzy rough set reduces to a fuzzy set.

6. Give an example of a fuzzy rough set from real life.

A fuzzy rough set is useful in situations where information is both uncertain and incomplete
— a common scenario in real-life decision-making. Here's a practical example from the medical
field:

Real-Life Example: Medical Diagnosis

Let’s consider the task of diagnosing “high risk” heart disease patients in a hospital.

● The universe UUU is the set of all patients in a hospital database.

● The attribute set includes fuzzy information like:

○ Blood pressure (e.g., "high", "moderate", "low")

○ Cholesterol levels ("elevated", "borderline")

○ Chest pain type ("severe", "mild")

● The target concept is the set of patients at high risk of heart disease — which is a fuzzy
set, because risk isn’t a strict yes/no condition but depends on degrees of severity.

Now, due to missing data or indistinguishable symptoms, the indiscernibility relation (rough set
concept) can’t clearly separate some patients — for instance, two patients may have similar
symptoms but one has missing test results.

To model this:

● Use a fuzzy equivalence relation to group patients based on similarity of symptoms

(not exact matches).

● Use lower approximation to identify patients definitely at high risk.

● Use upper approximation to include those who possibly belong to the risk group due to
uncertainty.

Fuzzy rough sets are ideal in such medical scenarios where both fuzziness (imprecise data) and
roughness (incomplete information) coexist, allowing better risk classification and patient
monitoring.
7. Define a rough fuzzy set and show how it is different from fuzzy rough sets.

Definition of Rough Fuzzy Set:

A rough fuzzy set is a hybrid soft computing model that combines the
principles of rough set theory and fuzzy set theory — but in a reverse
manner compared to fuzzy rough sets.

In this model, the universe U is first divided into crisp equivalence

classes using a rough set approach, and then within each class,
elements have fuzzy membership values.

According to the document, for a fuzzy set X, the rough

approximations are defined as:
- Lower Approximation:
RX(X) = inf_{y ∈ X_i} μ_X(y) (Eq. 16.10)
- Upper Approximation:
RX(X) = sup_{y ∈ X_i} μ_X(y) (Eq. 16.11)

Where X_i is an equivalence class in the partition U/R.

Difference from Fuzzy Rough Sets:

Aspect Fuzzy Rough Set Rough Fuzzy Set

Order of Application Fuzziness applied after Rough approximation

rough relations applied after fuzziness

Equivalence Relation Type Fuzzy relation (fuzzy Crisp equivalence relation

reflexive, symmetric, (partition-based)
transitive)

Target Set Crisp set approximated Fuzzy set approximated

using fuzzy similarity using rough approximation

Lower Approximation Based on fuzzy similarity Infimum of fuzzy

between elements membership in equivalence
 classes

Upper Approximation Based on maximum fuzzy Supremum of fuzzy

similarity membership in equivalence
classes

A fuzzy rough set uses fuzzy relations to approximate a crisp set, while a rough fuzzy set uses
crisp relations to approximate a fuzzy set. Both are used to handle uncertain and imprecise data
but differ in their structure and application order.

8. Define an intuitionistic fuzzy equivalence relation. Give an example and compute the
intuitionistic fuzzy equivalence classes.

Definition:

An intuitionistic fuzzy relation S is said to be an intuitionistic fuzzy equivalence relation if it is

intuitionistic fuzzy reflexive, intuitionistic fuzzy symmetric, and intuitionistic fuzzy transitive,
which are defined as follows:

• Intuitionistic fuzzy reflexivity (Eq. 16.20): μ(x, x) = 1, x U

• Intuitionistic fuzzy symmetry (Eq. 16.21): μ(x, y) = μ(y, x) and ν(x, y) = ν(y, x), x, y U

• Intuitionistic fuzzy transitivity (Eq. 16.22): μ(x, z) ≥ min{μ(x, y), μ(y, z)} and ν(x, z) ≤
max{ν(x, y), ν(y, z)}, x, y, z U

Where π(x, y) = 1 − μ(x, y) − ν(x, y) is the hesitation margin.

Example:

Let U = {a, b, c}. Define the intuitionistic fuzzy relation S as:

a b c

a (1.0, 0.0) (0.7, 0.2) (0.6, 0.3)

b (0.7, 0.2) (1.0, 0.0) (0.6, 0.3)

c (0.6, 0.3) (0.6, 0.3) (1.0, 0.0)

This relation satisfies:
✓ Reflexivity – all diagonal values have μ = 1 and ν = 0.
✓ Symmetry – all μ and ν values are symmetric.
✓ Transitivity – holds in all combinations, e.g., μ(a,c) = 0.6 = min(μ(a,b), μ(b,c)) =
min(0.7, 0.6), and ν(a,c) = 0.3 = max(ν(a,b), ν(b,c)) = max(0.2, 0.3).

Intuitionistic Fuzzy Equivalence Classes:

The equivalence class of an element x ∈ U under S is defined as:

[x]_S = { (μ(x, y), ν(x, y)) | y U } (Eq. 16.23)

[a] = { (1.0, 0.0), (0.7, 0.2), (0.6, 0.3) }

[b] = { (0.7, 0.2), (1.0, 0.0), (0.6, 0.3) }

[c] = { (0.6, 0.3), (0.6, 0.3), (1.0, 0.0) }

Each class shows the degree of membership and non-membership of each element relative to the
reference element, along with the implied hesitation.

9. Define an intuitionistic fuzzy rough set and provide an example.

An intuitionistic fuzzy rough set is a hybrid model that combines the concepts of intuitionistic
fuzzy sets and rough sets. It is used to deal with data that is imprecise, uncertain, and vague,
incorporating both fuzzy membership and non-membership information as well as
indiscernibility (equivalence) relations from rough set theory.

An intuitionistic fuzzy set is defined on a universe U with:

- A membership function μ_X(x)
- A non-membership function ν_X(x)
- A hesitation margin π_X(x) = 1 - μ_X(x) - ν_X(x)

Let R be a crisp equivalence relation that partitions U into equivalence classes [x]_R.

The intuitionistic fuzzy rough approximations of a set X are defined as:

• Lower Approximation:
̲_R(X)(x) = inf_{y [x]_R} μ_X(y)

• Upper Approximation:
 ̄_R(X)(x) = sup_{y [x]_R} μ_X(y)

• Non-Membership Bounds:
ν̲_R(X)(x) = sup_{y [x]_R} ν_X(y)

ν̄_R(X)(x) = inf_{y [x]_R} ν_X(y)

Thus, the intuitionistic fuzzy rough set is represented as:

([ ̲_R(X), ̄_R(X)], [ν̲_R(X), ν̄_R(X)])

Example:

Let U = {x , x , x , x } and the intuitionistic fuzzy set X be defined as:

Element μ_X ν_X

x 0.8 0.1

x 0.6 0.2

x 0.4 0.3

x 0.2 0.5

Let R be a crisp equivalence relation such that:

[x ]_R = [x ]_R = {x , x } and [x ]_R = [x ]_R = {x , x }

Now compute the approximations:

For x :

̲_R(X)(x ) = inf{0.8, 0.6} = 0.6

̄_R(X)(x ) = sup{0.8, 0.6} = 0.8

ν̲_R(X)(x ) = sup{0.1, 0.2} = 0.2

ν̄_R(X)(x ) = inf{0.1, 0.2} = 0.1

For x :

̲_R(X)(x ) = inf{0.4, 0.2} = 0.2

 ̄_R(X)(x ) = sup{0.4, 0.2} = 0.4

ν̲_R(X)(x ) = sup{0.3, 0.5} = 0.5

ν̄_R(X)(x ) = inf{0.3, 0.5} = 0.3

10. Define a rough intuitionistic fuzzy set and state how it is different from an intuitionistic
fuzzy rough set.

11. State the rough fuzzy C-means algorithm and explain its superiority over the individual
algorithms.

The Rough Fuzzy C-Means (RFCM) algorithm, proposed by Maji and Pal in 2007, is a C-means
clustering algorithm that incorporates both fuzzy sets and rough sets.

● It integrates the concept of fuzzy membership from fuzzy sets and the lower and upper
approximations from rough sets into the traditional C-means algorithm.
● Fuzzy sets enable effective handling of overlapping partitions, while rough sets address
uncertainty, vagueness, and incompleteness in class definitions.
● The algorithm generates C clusters from a set of n input objects.
● Each cluster is viewed as a rough fuzzy set, characterized by its A-lower approximation,
A-upper approximation, and boundary region.
● Cluster lower approximations do not share elements, but cluster boundaries may have
common elements.
● The algorithm minimizes an objective function to partition the n objects into C clusters

The Rough Fuzzy C-Means (RFCM) algorithm is more efficient than the individual classification
algorithms of fuzzy C-means and rough C-means.

Specifically, it combines the strengths of both:

● Fuzzy C-means: Efficiently handles overlapping partitions due to the use of fuzzy
membership.
● Rough sets: Deals with uncertainty, vagueness, and incompleteness in class definitions.

By integrating these features, RFCM aims to provide improved classification performance

compared to using either fuzzy C-means or rough C-means alone.
12. Write a pseudo-code for the RFCM.
Pseudo-code representation of the Rough Fuzzy C-Means (RFCM) algorithm
1. Initialize:
○ Assign initial centroids , for i = 1, 2, ..., C.
○ Choose a value for the fuzzifier "m" (typically, m = 2).
○ Set thresholds α and δ.
○ Initialize the iteration counter t = 1.
2. Compute Membership:
○ Compute μij​ using Equation (16.14) for C clusters and n objects.
○ The equation (16.14) is: μij​=(∑k=1C​(dkj​dij​​)(m−1)2​)−1
○ Where dij2 = xj −vi 2
3. Determine Upper Approximation:
○ Find the two highest membership values of object xj , μij​ and μkj​.
○ If (μij −μkj )<δ:
■ xj belongs to the upper approximation of both
cluster Ci and cluster Ck (i.e., xj ∈A(Ci ) and
xj ∈A(Ck )).
■ xj​ is not a part of any lower approximation.
○ Otherwise:
■ xj belongs to the upper approximation of cluster
Ci (i.e., xj ∈A(Ci )).
4. Modify Membership:
○ Adjust μij​ considering the lower and boundary regions for C clusters and n
objects. (The document doesn't provide a specific equation for this modification,
but it's a key step in incorporating the rough set concept).
5. Compute Centroids:
○ Compute the new centroids vi​ using Equation (16.17):
○ vi ={wlow ×Ei +wup ×Fi , if A (Ci )= and
B(Ci )= Ei , if A (Ci )= and B(Ci )= Fi , if
A (Ci )= and B(Ci )=
○ Where Ei = A (Ci ) 1 ∑xj ∈A (Ci ) xj ,
Fi =ni 1 ∑xj ∈B(Ci ) (μij )m xj , and
ni =∑xj ∈B(Ci ) (μij )m
6. Repeat:
○ Increment the iteration counter: t = t + 1.
○ Repeat steps 2-7 until the change in membership is below a
threshold: μij (t)−μij (t+1) < .
13. State the rough intuitionistic fuzzy C-means algorithm and explain its superiority over
the rough fuzzy C-means algorithm.

The Rough Intuitionistic Fuzzy C-Means (RIFCM) algorithm combines the concepts of rough
sets and intuitionistic fuzzy sets.

● Combination: It integrates IFCM (Intuitionistic Fuzzy C-Means) and RCM (Rough C-

Means). It can also be viewed as an extension of RFCM (Rough Fuzzy C-Means) that
incorporates Intuitionistic Fuzzy Sets (IFS).
● Concepts Included:
○ Lower and upper approximations from rough set theory.
○ Fuzzy membership from fuzzy sets.
○ Non-membership and hesitation values from intuitionistic fuzzy set theory.
● Goal: RIFCM aims to provide a comprehensive approach to data clustering. It addresses:
○ Uncertainty
○ Vagueness
○ Incompleteness
● Benefits:
○ Efficient handling of overlapping partitions.
○ Improved accuracy.
● Cluster properties:
○ A centroid
○ A crisp lower approximation
○ An intuitionistic fuzzy boundary
● Key aspects:
○ Objects in the lower approximation of a cluster have a membership value of 1 and
 a hesitation value of 0, exerting equal influence on the cluster.
○ Objects in the boundary region of a cluster may belong to multiple clusters, and
thus have varying degrees of influence on the cluster.

RIFCM's Superiority over RFCM:

RIFCM is considered superior to RFCM. It "has also been established to be more efficient than
the rough fuzzy C-means algorithm." The key advantage of RIFCM is that it incorporates
intuitionistic fuzzy sets, which include non-membership and hesitation values, in addition to the
fuzzy membership and rough set concepts used in RFCM. This allows RIFCM to handle
uncertainty and vagueness in a more comprehensive manner.

14. Write a pseudo-code for the RIFCM.

Pseudo-code for the RIFCM algorithm

1. Initialize:
○ Assign initial means for clusters by choosing any random objects as cluster.
2. Calculate Distance:
○ Calculate dij​ using Euclidean distance formula:

3. Compute U matrix:
○ Compute μij

○
4. Compute ηij by using the formula:
○ ηij = 1 - μij
5. Compute and normalize hesitation.
6. Let μimax and μjmax2 be the maximum and next to maximum membership values of
object xj to cluster centroids vi and vj

7. Calculate new cluster means by using

 8. Repeat from Step 2 until termination condition is met or until there are no more
assignment of objects.

RIFCM Algorithm: A Simplified Explanation

The RIFCM algorithm is a way to group similar data points into clusters. It's like sorting things
into categories, but it's designed to handle situations where the categories aren't very clear-cut. It
combines ideas from a few different approaches:
● Fuzzy Sets: Instead of each data point belonging to only one cluster, it can belong to
multiple clusters with different degrees of membership. Think of it like saying a person is
"a little bit" in one group and "mostly" in another.
● Rough Sets: This helps deal with uncertainty. For each cluster, there's a "core" of data
points that definitely belong to it (the lower approximation) and a "boundary" of points
that might belong to it (the upper approximation).
● Intuitionistic Fuzzy Sets: This adds the idea of "non-membership" and "hesitation." So,
for each data point and each cluster, we track how much the point belongs to the cluster,
how much it doesn't belong, and how much we're unsure about its membership.

Here's a simplified step-by-step explanation of the algorithm:

1. Start with Guesses:
○ Pick some initial "average points" (centroids) for each cluster. These are our
starting guesses for the center of each category.
2. Measure Distance:
○ For each data point, calculate how far it is from each cluster's average point.
3. Calculate Membership:
○ Determine how much each data point belongs to each cluster. This is based on the
distance calculated in the previous step.
■ If a point is very close to a cluster's average, it has a high membership
value for that cluster.
■ If a point is in the "core" of a cluster, its membership is 1 (full
membership).
4. Calculate Non-Membership:
 ○ For each data point and cluster, calculate how much the point doesn't belong to
the cluster. This is usually related to the membership value (e.g., non-membership
= 1 - membership).
5. Calculate Hesitation:
○ Calculate how unsure we are about the point's membership in each cluster.
6. Define Cluster Boundaries:
○ For each data point, determine if it's in the "core" of a cluster or on the
"boundary" between clusters. This is based on the membership values.
7. Recalculate Averages:
○ Calculate new "average points" for each cluster, taking into account the
membership, non-membership, and hesitation of the data points. Points in the
"core" of a cluster have a stronger influence on the average than points on the
boundary.
8. Repeat:
○ Repeat steps 2-7 until the cluster assignments stop changing significantly.

In essence: The algorithm starts with a rough idea of where the clusters are, then iteratively
refines those clusters by looking at how much each data point belongs to each cluster, how much
it doesn't, and how unsure we are about its membership. It keeps adjusting the cluster centers
until the assignments stabilize.

15. Write a short note on fuzzy genetic algorithms.

Fuzzifying Genetic Algorithms

Classical genetic algorithms typically use binary strings (strings of 0s and 1s) to represent
solutions. Fuzzy genetic algorithms extend this concept by incorporating fuzzy logic, which
allows for degrees of membership rather than strict binary values. This enables the algorithm to
handle uncertainty and vagueness in a more natural way.

There are two main ways to fuzzify genetic algorithms:

1. Fuzzy Genes: Fuzzify the gene pool and chromosome coding (e.g., extending the gene
pool from {0, 1} to the interval [0, 1]). Instead of using a gene pool of {0, 1}, fuzzy
genetic algorithms use a gene pool that includes values in the interval [0, 1]. This means
that a gene can take on any value between 0 and 1, representing a degree of membership.
2. Fuzzy Operators: Fuzzify operations on chromosomes.The genetic operators (crossover
and mutation) can also be fuzzified. This involves using fuzzy logic to determine how
these operations are applied, allowing for more flexible and nuanced manipulation of the
chromosomes.
By combining genetic algorithms with fuzzy logic, fuzzy genetic algorithms can effectively
handle complex optimization problems that involve uncertainty, imprecision, and vagueness.

16. Define neuro-fuzzy systems and state their applications.

Definition:

Neuro-fuzzy systems are a hybrid approach that combines the strengths of neural networks and
fuzzy logic.
● Neural networks are good at modeling complex nonlinear relationships and classifying
data.
● Fuzzy logic can handle imprecise inputs and outputs by defining them as fuzzy sets.

Applications: Neuro-fuzzy systems are used to:

● Specify mathematical relationships among variables in complex dynamic processes.

● Perform mappings with some degree of imprecision.
● Control nonlinear systems, often more effectively than traditional linear control systems.

There are several neuro-fuzzy systems in the literature. Some of these are as follows:
● Cooperative neuro-fuzzy systems
● Concurrent neuro-fuzzy systems
● Fused neuro-fuzzy systems

In a cooperative neuro-fuzzy model, an ANN learning mechanism determines the FIS

membership functions or fuzzy rules from the training data. Once the FIS parameters are
determined, ANN goes into the background. The rule base is usually determined by a clustering
approach or fuzzy clustering algorithms. Membership functions are usually approximated by a
neural network from the training data.

In a concurrent model, the ANN assists the FIS continuously to determine the required
parameters, especially if the input variables of the controller cannot be measured directly. In
some cases, the FIS outputs might not be directly applicable to the process. In that case, the ANN
can act as a postprocessor of FIS outputs.

In a fused NF architecture, ANN learning algorithms are used to determine the parameters of
FIS. Fused NF systems share data structures. A common way to apply a learning algorithm to a
fuzzy system is to represent it in a special ANN-like architecture. However, the conventional
ANN learning algorithms cannot be applied directly to such a system as the functions used in the
inference process are usually non-differentiable. This problem can be tackled by using
differentiable functions in the inference system or by not using the standard neural algorithm.