ARTIFICIAL INTELLIGENCE

AND
EXPERT SYSTEMS (CSE209)
 Introduction
Building Expert System using Fuzzy Logic
• Introduction to fuzzy logic
• Fuzzification
• Techniques of Fuzzification
• Defuzzification
• Techniques of Defuzzification
• Rule designing and inferencing, Fuzzy
• Inference System: Mamdani Fuzzy Model and Examples, Larsen Fuzzy
Model, Tsukamoto Fuzzy Model and TSK Fuzzy Model

2
 What is Fuzzy Logic?

The 'Fuzzy' word means the things that are not clear or are vague.
Sometimes, we cannot decide in real life that the given problem or
statement is either true or false. At that time, this concept provides
many values between the true and false and gives the flexibility to
find the best solution to that problem.
 Characteristics of Fuzzy Logic

Following are the characteristics of fuzzy logic:

1.This concept is flexible and we can easily understand and implement it.

2.It is used for helping the minimization of the logics created by the human.

3.It is the best method for finding the solution of those problems which are suitable for
approximate or uncertain reasoning.

4.It always offers two values, which denote the two possible solutions for a problem and
statement.

5.It allows users to build or create the functions which are non-linear of arbitrary
complexity.
6. In fuzzy logic, everything is a matter of degree.

7.In the Fuzzy logic, any system which is logical can be easily fuzzified.

8. It is based on natural language processing.

9. It is also used by the quantitative analysts for improving their algorithm's

execution.

10.It also allows users to integrate with the programming.

 Architecture of a Fuzzy Logic System

In the architecture of the Fuzzy Logic system, each component plays an important role.
The architecture consists of the different four components which are given below.
1.Rule Base
2.Fuzzification
3.Inference Engine
4.Defuzzification
1. Rule Base
Rule Base is a component used for storing the set of rules and the If-Then conditions
given by the experts are used for controlling the decision-making systems. There are so
many updates that come in the Fuzzy theory recently, which offers effective methods
for designing and tuning of fuzzy controllers. These updates or developments decreases
the number of fuzzy set of rules.

2. Fuzzification
Fuzzification is a module or component for transforming the system inputs, i.e., it
converts the crisp number into fuzzy steps. The crisp numbers are those inputs which
are measured by the sensors and then fuzzification passed them into the control
systems for further processing. This component divides the input signals into following
five states in any Fuzzy Logic system:
•Large Positive (LP)
•Medium Positive (MP)
•Small (S)
•Medium Negative (MN)
•Large negative (LN)
3. Inference Engine
This component is a main component in any Fuzzy Logic system (FLS), because all the
information is processed in the Inference Engine. It allows users to find the matching degree
between the current fuzzy input and the rules. After the matching degree, this system
determines which rule is to be added according to the given input field. When all rules are
fired, then they are combined for developing the control actions.

4. Defuzzification
Defuzzification is a module or component, which takes the fuzzy set inputs generated by
the Inference Engine, and then transforms them into a crisp value. It is the last step in
the process of a fuzzy logic system. The crisp value is a type of value which is acceptable by
the user. Various techniques are present to do this, but the user has to select the best one
for reducing the errors.
The membership function is a function which represents the graph of fuzzy sets,
and allows users to quantify the linguistic term. It is a graph which is used for
mapping each element of x to the value between 0 and 1.

This function is also known as indicator or characteristics function.

For the Fuzzy set B, the membership function for X is defined as: μB:X → [0,1]. In
this function X, each element of set B is mapped to the value between 0 and 1.
This is called a degree of membership or membership value.
Fuzzy set operations with example
Techniques of Fuzzification
1.Singleton Fuzzification: Assigns a degree of membership that is 1 for a specific value
and 0 otherwise.
2.Gaussian Fuzzification: Uses a Gaussian curve to map input values to a membership
degree.
3.Trapezoidal and Triangular Fuzzification: Uses trapezoidal or triangular shapes to
define membership functions, providing a linear increase and decrease in the
membership degree.
NOTE: Follow the below Code to implement all fuzzy operations using
python for hands on practice in class

Libraries required: numpy, skfuzzy(install scikit-fuzzy), matplotlib

import numpy as np
import skfuzzy as fuzz
import matplotlib.pyplot as plt

# Defining the universe of discourse (input range)

x = np.arange(0, 11, 1)
print("crisp set X:",x)

# Defining fuzzy sets A and B

A = fuzz.trimf(x, [0, 0, 5]) # Membership function for set A
(e.g., "low temperature")
B = fuzz.trimf(x, [5, 10, 10]) # Membership function for set
B (e.g., "high temperature")

print("fuzzy set A:",A)

print("fuzzy set B:",B)
A_not = 1 - A
print("notA:",A_not)

# Fuzzy AND operation (intersection of sets A and B

using the min operator)
A_and_B = np.fmin(A, B)
print("Intersection:",A_and_B)

# Fuzzy OR operation (union of sets A and B using the

max operator)
A_or_B = np.fmax(A, B)
print("union:",A_or_B)

# Visualizing the fuzzy operations

plt.figure(figsize=(10, 8))

# Plotting set A
plt.subplot(2, 2, 1)
plt.plot(x, A, label='Set A', color='blue')
plt.title('Fuzzy Set A')
plt.xlabel('x')
plt.ylabel('Membership Degree')
# Plotting set B
plt.subplot(2, 2, 2)
plt.plot(x, B, label='Set B', color='red')
plt.title('Fuzzy Set B')
plt.xlabel('x')
plt.ylabel('Membership Degree')

plt.subplot(2, 2, 3)
plt.plot(x, A_not, label='NOT A', color='green')
plt.title('Fuzzy NOT A')
plt.xlabel('x')
plt.ylabel('Membership Degree')

# Plotting fuzzy AND (intersection of sets A and B)

plt.subplot(2, 2, 4)
plt.plot(x, A_and_B, label='A AND B', color='purple')
plt.title('Fuzzy AND (A and B)')
plt.xlabel('x')
plt.ylabel('Membership Degree')

# Displaying the results

plt.tight_layout()
plt.show()
 Different ways of fuzzification

import numpy as np
import skfuzzy as fuzz
import matplotlib.pyplot as plt

# Define the universe of discourse (input range for

temperature)
temperature = np.arange(0, 41, 1) # Temperature values
from 0 to 40°C
print("crisp set temperature:",temperature)
# Fuzzification methods

# 1. Triangular Membership Function

temp_triangular = fuzz.trimf(temperature, [10, 20, 30])
print("fuzzy set tri mv:",temp_triangular)

# 2. Trapezoidal Membership Function

temp_trapezoidal = fuzz.trapmf(temperature, [10, 15, 25,
30])
print("fuzzy set trap mv:",temp_trapezoidal)
# 3. Gaussian Membership Function
temp_gaussian = fuzz.gaussmf(temperature, 20, 5) # mean = 20,
sigma = 5
print("fuzzy set gau mv:",temp_gaussian)
# Plotting the membership functions to show fuzzification

plt.figure(figsize=(10, 6))

# Plot for Triangular Membership Function

plt.plot(temperature, temp_triangular, label="Triangular",
color='blue')
plt.title("Triangular Membership Function for Temperature")
plt.xlabel("Temperature (°C)")
plt.ylabel("Membership Degree")
plt.legend()
plt.grid(True)
plt.show()
# Plot for Trapezoidal Membership Function
plt.plot(temperature, temp_trapezoidal,
label="Trapezoidal", color='green')
plt.title("Trapezoidal Membership Function for
Temperature")
plt.xlabel("Temperature (°C)")
plt.ylabel("Membership Degree")
plt.legend()
plt.grid(True)
plt.show()

# Plot for Gaussian Membership Function

plt.plot(temperature, temp_gaussian, label="Gaussian",
color='red')
plt.title("Gaussian Membership Function for Temperature")
plt.xlabel("Temperature (°C)")
plt.ylabel("Membership Degree")
plt.legend()
plt.grid(True)
plt.show()
Problem Statement using fuzzy logic (construction of small fuzzy system)

1. Weather classification: Construct a small fuzzy system to classify weather conditions.

Use inputs like temperature (20°C, 30°C, 40°C), humidity (30%, 70%), and wind speed (5 km/h, 20 km/h).
Show how the fuzzy system determines whether the weather is sunny, cloudy, or rainy.

2. Tip to a waiter: Design a fuzzy logic-based system to determine the appropriate tip to be given to a
waiter based on two key inputs: Food Quality and Service Quality. Both inputs are subjective and can
vary between poor, average, and excellent. The system should use fuzzy rules to compute a tip percentage,
taking into account the varying degrees of food and service satisfaction. The aim is to provide a more nuanced
and fair tip calculation, reflecting the overall dining experience rather than relying on rigid tipping percentages.
import numpy as np
import matplotlib.pyplot as plt
import skfuzzy as fuzz

temperature = np.arange(0, 41, 1)

humidity = np.arange(30, 70, 1)
wind = np.arange(5, 21, 1)

sunny = fuzz.trimf(humidity, [30, 40, 50])

cloudy = fuzz.trimf(humidity, [40, 50, 60])
rainy = fuzz.trimf(humidity, [50, 60, 70])

cold = fuzz.trimf(temperature, [0, 0, 20])

warm = fuzz.trimf(temperature, [15, 25, 35])
hot = fuzz.trimf(temperature, [30, 40, 40])

low_wind = fuzz.trimf(wind, [5, 5, 10])

moderate_wind = fuzz.trimf(wind, [8, 12, 16])
high_wind = fuzz.trimf(wind, [14, 20, 20])
plt.figure(figsize=(10, 5))
plt.plot(temperature, cold, label='Cold', color='blue')
plt.plot(temperature, warm, label='Warm', color='orange')
plt.plot(temperature, hot, label='Hot', color='red')

plt.title('Fuzzy Temperature Classification')

plt.xlabel('Temperature (°C)')
plt.ylabel('Membership Degree')
plt.legend()
plt.grid()
plt.show()

def classify_weather(temp, wind_speed, humid):

cold_degree = fuzz.interp_membership(temperature, cold, temp)
warm_degree = fuzz.interp_membership(temperature, warm, temp)
hot_degree = fuzz.interp_membership(temperature, hot, temp)

low_wind_degree = fuzz.interp_membership(wind, low_wind, wind_speed)

moderate_wind_degree = fuzz.interp_membership(wind, moderate_wind,
wind_speed)
high_wind_degree = fuzz.interp_membership(wind, high_wind, wind_speed)
 #inside function contd..

sunny_degree = fuzz.interp_membership(humidity, sunny, humid)

cloudy_degree = fuzz.interp_membership(humidity, cloudy,
humid)
rainy_degree = fuzz.interp_membership(humidity, rainy, humid)
# to measure overall value of combined factors
sunny_score = (hot_degree * low_wind_degree * sunny_degree)
cloudy_score = (warm_degree * moderate_wind_degree *
cloudy_degree)
rainy_score = (cold_degree * high_wind_degree * rainy_degree)

if sunny_score > cloudy_score and sunny_score > rainy_score:

return "Sunny"
elif cloudy_score > sunny_score and cloudy_score >
rainy_score:
return "Cloudy"
else:
return "Rainy"
#outside the function

user_temp = float(input("Enter the temperature : "))

user_wind = float(input("Enter the wind speed : "))
user_humidity = float(input("Enter the humidity percentage: "))

weather_type = classify_weather(user_temp, user_wind,

user_humidity)
print(f"The weather is classified as: {weather_type}")
#Code for problem statement 2: it is including only one factor ask students to include
2nd and practice by their own

import numpy as np
import skfuzzy as fuzz

# Define the universe of discourse (0 to 10 for service quality)

x = np.arange(0, 11, 1)

# Define membership functions for 'poor', 'average', and 'excellent' service

poor_service = fuzz.trimf(x, [0, 0, 5]) # Poor service: between 0 and 5
average_service = fuzz.trimf(x, [0, 5, 10]) # Average service: between 0 and 10
excellent_service = fuzz.trimf(x, [5, 10, 10]) # Excellent service: between 5 and 10

# Crisp value to evaluate

crisp_value = 8

# Calculate the degree of membership for the crisp value in each fuzzy set
membership_poor = fuzz.interp_membership(x, poor_service, crisp_value)
membership_average = fuzz.interp_membership(x, average_service, crisp_value)
membership_excellent = fuzz.interp_membership(x, excellent_service, crisp_value)
# Print the degree of membership for the crisp value in each fuzzy set

print(f"Degree of membership of {crisp_value} in 'Poor' service: {membership_poor:.2f}")

print(f"Degree of membership of {crisp_value} in 'Average' service: {membership_average:.2f}")

print(f"Degree of membership of {crisp_value} in 'Excellent' service: {membership_excellent:.2f}")