Navigating Uncertainty: Fuzzy Logic Applications

Fuzzy logic is a form of many-valued logic that deals with reasoning that is approximate rather than fixed and exact. Unlike traditional binary sets (where variables may only be 0 or 1), fuzzy logic variables may have a truth value that ranges between 0 and 1. This approach allows for the modeling of uncertainty and imprecise information, making it highly effective in a variety of fields.

The concept of fuzzy logic was introduced by Lotfi Zadeh, a professor at the University of California, Berkeley, through his seminal paper "Fuzzy Sets" in 1965. Zadeh proposed a new way of processing data by allowing partial set membership rather than a strict binary membership. This innovation was driven by the realization that human reasoning is often approximate and not always black and white. Initially, the field did not gain much traction in Western academic circles but saw significant applications and advancements in Japan during the 1980s and 1990s, particularly in the realms of control systems and consumer electronics.

Dealing with Uncertainty

Uncertainty is a fundamental concept in decision-making and data analysis that describes the lack of precise knowledge about the state of the world or the outcome of an event. It encompasses situations where information is incomplete, imprecise, ambiguous, or subject to variability. Dealing with uncertainty is essential in various fields, as many real-world problems do not have clear-cut, deterministic solutions but rather exist in a realm of vagueness and partial information.

Fuzzy logic stands out as a powerful tool for handling uncertainty in complex systems. Traditional logic relies on crisp distinctions, where a statement is either true or false, leading to challenges when dealing with nuanced or ambiguous data. Fuzzy logic, on the other hand, introduces the notion of truth values between 0 and 1, allowing for a more flexible representation of uncertainty. In a fuzzy logic system, variables can have degrees of truth or membership, enabling a seamless transition between categories and facilitating reasoning in the face of imprecise or incomplete information.

In practice, uncertainty manifests in various scenarios where conventional binary logic falls short. For instance, in quality assessment tasks like wine grading or medical diagnosis, subjective criteria and incomplete data introduce uncertainty in decision-making. Fuzzy logic excels in these domains by capturing the inherent imprecision and subjectivity through fuzzy sets, membership functions, and fuzzy rules. By embracing uncertainty as a fundamental aspect of modeling, fuzzy logic empowers systems to make intelligent and adaptive decisions in the presence of vagueness and variability.

The Components of Fuzzy Logic Systems

Fuzzy logic is built upon the concept of fuzzy sets, which are an extension of classical set theory. Here are some key components of fuzzy logic systems:

Fuzzy Sets: Unlike classical sets, where elements are either part of the set or not (0 or 1), fuzzy sets allow for partial membership. For example, an element can belong to a fuzzy set with a degree of membership ranging from 0 to 1.

Membership Functions: These functions define how each point in the input space is mapped to a membership value between 0 and 1. Common shapes for these functions include triangular, trapezoidal, and Gaussian.

Fuzzy Rules: Fuzzy logic uses if-then rules to model the relationships between input and output variables. These rules are usually derived from expert knowledge.

Fuzzification: The process of converting crisp input values into degrees of membership for fuzzy sets.

Inference Engine: This component applies fuzzy rules to the fuzzified inputs to generate fuzzy outputs.

Defuzzification: The process of converting fuzzy output values back into a single crisp value, which can be used for decision-making or control.

Applications of Fuzzy Logic

Fuzzy logic has found applications across various domains due to its ability to handle uncertain and imprecise information. Some notable applications include:

Control Systems

Fuzzy logic controllers are used in a variety of industrial applications such as automatic transmission systems, air conditioning systems, and camera autofocus systems. Fuzzy logic provides a robust and flexible way to manage the imprecision inherent in these systems.

• Autofocus systems in digital cameras use fuzzy logic to determine the focus based on the contrast and sharpness of the image (identified subject's fuzziness). This allows the camera to make fine adjustments and quickly focus on the subject.
• HVAC (Heating, Ventilation, and Air Conditioning) systems use fuzzy logic to maintain desired temperature and humidity levels based on external weather conditions, time of day, occupancy, and user preferences.

Consumer Electronics

Companies have extensively used fuzzy logic in their appliances.

• The fuzzy washing machines adjust washing cycles based on the type of clothes and load size. The machine can also adjust water levels, agitation patterns, and washing time by evaluating the "dirtiness" and fabric type, which are inherently fuzzy concepts.

https://www.samsung.com/in/support/home-appliances/what-is-fuzzy-logic-in-a-washing-machine/

Automotive Systems

Fuzzy logic is used in vehicle braking, cruise control, and climate control systems. These systems benefit from fuzzy logic's ability to smoothly handle transitions and variations in real-world conditions.

Decision Support Systems

In fields like medicine, finance, and environmental management, fuzzy logic is used to make decisions based on a variety of imprecise and subjective inputs.

• The fuzzy logic can assist in diagnosing diseases by evaluating symptoms that do not have clear-cut categories. For instance, the severity of pain or the degree of swelling can be described using fuzzy terms rather than precise measurements.

Robotics

Fuzzy logic manages robots' behavior, allowing them to make decisions based on uncertain sensory data.

Fuzzy Logic and Python

Example A: Determining the Tip Amount

Let's create a simple fuzzy logic example using Python for a real-life problem. We will use a fuzzy logic library called "scikit-fuzzy". The example will focus on a basic fuzzy logic controller for determining the "tip" amount that a customer should give based on the service quality and the food quality.

First, we need to install the scikit-fuzzy library.

pip install scikit-fuzzy        

Python code:

import numpy as np
import skfuzzy as fuzz
from skfuzzy import control as ctrl

# Define the universe of discourse for each variable
x_service = np.arange(0, 11, 1)
x_food = np.arange(0, 11, 1)
x_tip = np.arange(0, 26, 1)

# Define fuzzy membership functions
service_lo = fuzz.trimf(x_service, [0, 0, 5])
service_md = fuzz.trimf(x_service, [0, 5, 10])
service_hi = fuzz.trimf(x_service, [5, 10, 10])
food_lo = fuzz.trimf(x_food, [0, 0, 5])
food_md = fuzz.trimf(x_food, [0, 5, 10])
food_hi = fuzz.trimf(x_food, [5, 10, 10])
tip_lo = fuzz.trimf(x_tip, [0, 0, 13])
tip_md = fuzz.trimf(x_tip, [0, 13, 25])
tip_hi = fuzz.trimf(x_tip, [13, 25, 25])

# Define fuzzy variables
service = ctrl.Antecedent(x_service, 'service')
food = ctrl.Antecedent(x_food, 'food')
tip = ctrl.Consequent(x_tip, 'tip')

service['low'] = service_lo
service['medium'] = service_md
service['high'] = service_hi
food['low'] = food_lo
food['medium'] = food_md
food['high'] = food_hi
tip['low'] = tip_lo
tip['medium'] = tip_md
tip['high'] = tip_hi

# Define the rules
rule1 = ctrl.Rule(service['low'] & food['low'], tip['low'])
rule2 = ctrl.Rule(service['low'] & food['medium'], tip['low'])
rule3 = ctrl.Rule(service['low'] & food['high'], tip['medium'])
rule4 = ctrl.Rule(service['medium'] & food['low'], tip['low'])
rule5 = ctrl.Rule(service['medium'] & food['medium'], tip['medium'])
rule6 = ctrl.Rule(service['medium'] & food['high'], tip['high'])
rule7 = ctrl.Rule(service['high'] & food['low'], tip['medium'])
rule8 = ctrl.Rule(service['high'] & food['medium'], tip['high'])
rule9 = ctrl.Rule(service['high'] & food['high'], tip['high'])

# Create a control system
tipping_ctrl = ctrl.ControlSystem([rule1, rule2, rule3, rule4, rule5, rule6, rule7, rule8, rule9])
tipping = ctrl.ControlSystemSimulation(tipping_ctrl)

# Input values
tipping.input['service'] = 6.5
tipping.input['food'] = 9.8

# Compute the output
tipping.compute()

# Output the tip
print(f"Suggested tip: {tipping.output['tip']:.2f}")        

Key elements of the code:

• fuzzy variables: service, food, and tip
• membership functions for each fuzzy set within variables
• rules that define how the service and food quality map to the tip
• control system

Simulate the control system with specific inputs:

# Input values
tipping.input['service'] = 6.5
tipping.input['food'] = 9.8        

Testing:

The Python code above calculates a suggested tip based on the provided service and food quality. You can modify the values of “service” and “food” to see different tipping amounts.

Example B: Classifying Wine Quality

In this example, we will use the Wine Quality dataset from the UCI Machine Learning Repository. This dataset is commonly used for classification and regression tasks. We'll focus on classifying wine quality based on its physicochemical properties.

Problem Statement: Given various physicochemical features of wine, predict the quality of the wine.

In the provided fuzzy logic system for predicting wine quality, there are three input variables: alcohol content, sulphates level, and citric acid content.

Alcohol Content: The alcohol content of the wine is an important factor. In this fuzzy system:

• High alcohol content or low alcohol content leads to lower predicted quality ("quality['low']").
• This suggests that extreme values of alcohol content, either very high or very low, are associated with lower-quality wine.

Sulphates Level: The level of sulphates in wine also influences the predicted quality:

• High sulphates level leads to lower predicted quality ("quality['low']").
• This indicates that a higher concentration of sulphates is linked to lower-quality wine in this system.

Citric Acid Content: The citric acid content in the wine is another input variable affecting the predicted quality:

• High citric acid content leads to higher predicted quality ("quality['high']").
• This implies that wines with a higher citric acid content are predicted to be of higher quality in this system.

Therefore, in this fuzzy system:

1. Very high or very low alcohol content, as well as high sulphate levels, are associated with lower predicted wine quality.
2. Conversely, wines with higher levels of citric acid are predicted to be of higher quality.

These relationships between the input variables (alcohol content, sulphates level, citric acid content) and the predicted wine quality are defined by the rules established in the fuzzy logic system. By adjusting the membership functions and rules, we can model and predict how these input variables collectively impact the predicted quality of the wine.

Disclaimer: The wine quality predictions provided by this fuzzy logic system are for educational purposes only. Please note that wine quality is subjective and influenced by various factors beyond the model's scope.

Full Python code:

import numpy as np
import pandas as pd
import skfuzzy as fuzz
from skfuzzy import control as ctrl

# Load the dataset
df = pd.read_csv("https://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-red.csv", sep=';')

# Define fuzzy variables and membership functions
alcohol = ctrl.Antecedent(np.arange(8, 15, 0.1), 'alcohol')
sulphates = ctrl.Antecedent(np.arange(0.3, 2.0, 0.1), 'sulphates')
citric_acid = ctrl.Antecedent(np.arange(0, 1, 0.1), 'citric_acid')
quality = ctrl.Consequent(np.arange(0, 11, 1), 'quality')

# Define membership functions for alcohol, sulphates, citric_acid, and quality

# Define membership functions for alcohol
alcohol['low'] = fuzz.trimf(alcohol.universe, [8, 8, 10])
alcohol['medium'] = fuzz.trimf(alcohol.universe, [8, 10, 12])
alcohol['high'] = fuzz.trimf(alcohol.universe, [10, 15, 15])

# Define membership functions for sulphates
sulphates['low'] = fuzz.trimf(sulphates.universe, [0.3, 0.3, 0.7])
sulphates['medium'] = fuzz.trimf(sulphates.universe, [0.5, 1.0, 1.5])
sulphates['high'] = fuzz.trimf(sulphates.universe, [1.0, 2.0, 2.0])

# Define membership functions for citric_acid
citric_acid['low'] = fuzz.trimf(citric_acid.universe, [0, 0, 0.4])
citric_acid['medium'] = fuzz.trimf(citric_acid.universe, [0.2, 0.4, 0.6])
citric_acid['high'] = fuzz.trimf(citric_acid.universe, [0.4, 1, 1])

# Define membership functions for quality
quality['low'] = fuzz.trimf(quality.universe, [0, 0, 5])
quality['medium'] = fuzz.trimf(quality.universe, [3, 5, 7])
quality['high'] = fuzz.trimf(quality.universe, [5, 10, 10])

# Define the rules
rule1 = ctrl.Rule(alcohol['high'] | alcohol['low'], quality['low'])
rule2 = ctrl.Rule(sulphates['high'], quality['low'])
rule3 = ctrl.Rule(citric_acid['high'], quality['high'])

# Create the control system
quality_ctrl = ctrl.ControlSystem([rule1, rule2, rule3])
quality_system = ctrl.ControlSystemSimulation(quality_ctrl)

# Testing the system with a sample data point
input_data = {"alcohol": 10.8, "sulphates": 0.6, "citric_acid": 0.3}  # Example input values

quality_system.input['alcohol'] = input_data["alcohol"]
quality_system.input['sulphates'] = input_data["sulphates"]
quality_system.input['citric_acid'] = input_data["citric_acid"]

# Compute the output
quality_system.compute()

# Print the output
predicted_quality = quality_system.output['quality']
print(f'Predicted wine quality: {predicted_quality:.2f}')        

Let's break down and focus on the key elements of the fuzzy logic system code provided:

Importing Libraries:

• import numpy as np - Importing NumPy for numerical operations.
• import pandas as pd - Importing Pandas for data manipulation.
• import skfuzzy as fuzz: - Importing SciKit-Fuzzy for fuzzy logic.
• from skfuzzy import control as ctrl: - Importing fuzzy control from SciKit-Fuzzy.

Membership Functions:

• Membership functions define how input/output variables are mapped to fuzzy membership degrees.
• Antecedent?defines input variables, and?Consequent?defines the output variable.
• Triangular membership functions are defined for variables like alcohol, sulphates, citric acid, and quality.

Rules:

• Rules determine how input variables influence the output variable. Each rule specifies a condition and its corresponding output.
• Example:?rule1 = ctrl.Rule(alcohol['high'] | alcohol['low'], quality['low'])?sets the rule for low wine quality based on high or low alcohol content.

Control System:

• ControlSystem?combines all rules into a control system.
• ControlSystemSimulation?creates a simulation using the defined control system.

Input Data:

• Sample input data is defined for alcohol, sulphates, and citric acid to test the system.

Fuzzy System Evaluation:

• Input values are provided to the system for computation.
• compute()?function calculates the output based on input values and rules.

Output Prediction:

• The predicted quality value is extracted from the system output.

Quality range

In the provided code snippet for the fuzzy logic system, the scale for the output variable "quality" is defined by the following line of code:

quality = ctrl.Consequent(np.arange(0, 11, 1), 'quality')        

The "Consequent" function creates the output variable "quality" with a defined scale. The scale for "quality" is set from 0 to 10 (inclusive), with increments of 1.

This means that the scale for the output variable "quality" in this fuzzy logic system ranges from 0 to 10, with 0 indicating the lowest predicted quality and 10 representing the highest predicted quality, and intermediate values representing varying levels of wine quality in between.

Testing the code:

Let's test it with some input variable combinations:

Interpretation of the results

A fuzzy logic system was used to predict wine quality by evaluating 10 wines (A to J) based on their alcohol, sulphates, and citric acid contents.

• Predicted Quality: Quality predictions ranged from 2.20 to 6.48. Wine C scored highest at 6.48 due to its specific content attributes, while Wine H scored lowest at 2.20.
• Variable Influence: Alcohol levels generally correlated with quality, except for extreme values. Higher sulphates were consistently associated with lower quality. Elevated citric acid levels tended to predict higher quality.

The fuzzy logic system effectively predicted wine quality, unveiling the intricate interplay of input variables and their impact on quality outcomes. Different combinations of alcohol, sulphates, and citric acid influenced predicted quality, revealing the system's ability to capture complex relationships in wine quality assessment.

Fuzzy logic is a powerful tool for dealing with uncertainty and imprecision in decision-making processes. As we have seen in the context of wine quality prediction or similar systems, fuzzy logic offers a flexible framework to model complex relationships between input variables and their effects on output variables like wine quality. By defining fuzzy sets, membership functions, rules, and a control system, fuzzy logic systems can provide insightful predictions that may not be easily achievable with traditional binary logic.

It's essential to note that fuzzy logic models depend on the accuracy of the defined membership functions, rules, and input data. Interpretation of the fuzzy model output should be done carefully, considering that fuzzy logic deals with linguistic variables and degrees of truth rather than precise values.

Fuzzy logic can be highly beneficial in scenarios where the relationships between variables are not explicitly defined or involve subjective assessments. By incorporating uncertainties into the analysis, it enables a more human-like decision-making process. Fuzzy logic can complement traditional analytical methods and expert knowledge, offering a valuable approach to handling complex systems that involve ambiguity and vagueness.

Neven Dujmovic, May 2024

#FuzzyLogic #Fuzzy #DecisionMaking #UncertaintyHandling #AdaptiveReasoning #DataAnalysis #ArtificialIntelligence #AI #MachineLearning #ML #Innovation #Tech #ProblemSolving #skfuzzy #pandas #numpy #quality