An Approach to Generating Fuzzy Rules for a Fuzzy Controller Based on the Decision Tree Interpretation

Abstract

This article describes solutions to control problems using fuzzy logic, which facilitates the development of decision support systems across various fields. However, addressing this task through the manual creation of rules in specific fields necessitates significant expert knowledge. Machine learning methods can identify hidden patterns. A key novelty of this approach is the algorithm for generating fuzzy rules for a fuzzy controller, derived from interpreting a decision tree. The proposed algorithm allows the quality of the control actions in organizational and technical systems to be enhanced. This article presents an example of generating a set of fuzzy rules through the analysis of a decision tree model. The proposed algorithm allows for the creation of a set of fuzzy rules for constructing fuzzy rule-based systems (FRBSs). Additionally, it autogenerates membership functions and linguistic term labels for all of the input and output parameters. The machine learning model and the FRBS obtained were assessed using the coefficient of determination ($R^2$). The experimental results demonstrated that the constructed FRBS performed on average 2% worse than the original decision tree model. While the quality of the FRBS could be enhanced by optimizing the membership functions, this topic falls outside the scope of the current article.

1. Introduction

Controlling complex technical systems involves analyzing large volumes of data. General control theory provides requirements for the data and signals associated with the control object. In addition, it is essential to consider the data features and characteristics and the limitations of the external environment. In our previous studies, we demonstrated that the choice of data analysis method and the quality of the analysis results are dependent on the context of the control problem [1,2].

The quality of the control task is affected by several factors, including the following:

• The complexity of the control object;
• The complexity of the control task;
• The volume of data available for analysis;
• The time constraints;
• The urgency of the decisions.

These factors require the selection of an appropriate class of mathematical models for control systems, guided by an analysis of the properties of the control object.

A complex technical system requires a reproducible and deterministic approach to control. It is necessary to develop a mathematical model of the object for control purposes when the behavior of an object is well understood [3]. However, sometimes, constructing a mathematical model is not possible. In such cases, rule-based systems or machine learning methods can address the control problem.

Machine learning methods introduce challenges related to the interpretability of the results. Understanding how the system makes its decisions is crucial for assessing the correctness of the results in fields where the cost of errors is significant [4,5].

Fuzzy inference systems (FISs) are used to address the control problem while balancing interpretability and quality [4,5,6]. An FIS is based on the principles of fuzzy logic and fuzzy inference algorithms.

The study presented in [6] provides a comprehensive classification of fuzzy inference systems (FISs) and explores the primary challenges associated with their development.

The following categories of FISs are identified:

• Fuzzy rule-based systems (FRBSs): FRBSs represent a traditional implementation of an FIS [6]. The structure of an FRBS is illustrated in Figure 1. A collection of numerical (crisp) inputs, denoted as X, is used as the FRBS’s input. This is followed by a fuzzification process, which calculates the membership degree for each input parameter from X in relation to the fuzzy set. Subsequently, fuzzy inference is organized based on a set of fuzzy rules, which determine the knowledge base of the FRBS, describing the behavioral characteristics of an object and its external environment. The defuzzification process then converts the fuzzy inference results into a set of crisp output parameters, represented as Y.
• Genetic/evolutionary fuzzy systems (GFSs): A GFS operates on principles similar to those of an FRBS but uses genetic and evolutionary algorithms to train and fine-tune the parameters [4,7,8]. These evolutionary techniques allow for the optimal set of fuzzy rules to be generated and the membership function parameters to be optimized.
• Hierarchical fuzzy systems (HFSs): An HFS also relies on the principles of an FRBS but addresses the challenge of maintaining a large number of logical rules [9,10,11,12,13]. This issue is resolved by constructing a set of simple fuzzy systems that are organized into a hierarchical structure.
• Neuro fuzzy systems (NFSs): An NFS builds on the FRBS scheme by integrating an FRBS with artificial neural networks. Although the FRBS can interpret the results, neural networks can learn to solve specific tasks [14,15,16]. Neural networks in NFSs are an alternative to the traditional set of fuzzy rules in FRBSs.

The fuzzy rule $r_i^F$ can be expressed as follows [17]:

$$r_i^F:\mathrm{if}\left(x_1\mathrm{is}{A}_1\right)\mathrm{and}\left(x_2\mathrm{is}{A}_2\right)\mathrm{and}\dots \mathrm{and}\left(x_n\mathrm{is}{A}_n\right)\to y_1\mathrm{is}{C}_1,$$

(1)

where $x_j\in X$ denotes the j-th input variable; $A_j\in A$ represents the fuzzy value associated with $x_j$; and $C_k$ indicates the fuzzy value of the rule consequent, which corresponds to the k-th output variable $y_k\in Y$.

The fuzzy inference process can be described in the following steps [18,19]:

• Fuzzification of the input values: Each value of the input variable $x_j$ linked to a fuzzy set A is characterized by a membership degree ${\mu }_A\left(x_i\right)\in \left[0,1\right]$. 
• Aggregation: The truth degree ${\delta }_i^A$ of the antecedent of the i-th rule is calculated based on the aggregation of the membership degrees of the input variables X. The specific aggregation method is determined by the algorithm in use, such as Mamdani, Sugeno, or Tsukamoto.
• Activation: The truth degree ${\delta }_i^C$ of the consequent of the i-th rule is calculated at the activation stage. If the consequent comprises a single fuzzy statement, its truth degree equals the algebraic product of the weight coefficient and the truth degree of an antecedent of the rule. Where the consequent comprises multiple statements, the truth degree of each statement is derived from the algebraic product of the weight coefficient and the truth degree ${\delta }_i^A$ of an antecedent of the rule. If the weight coefficient is unspecified, then the default value is one.
• Accumulation: A membership function F is constructed for all output variables during the accumulation phase. This function is constructed using the max union of the membership degrees of all fuzzy sets related to the k-th output variable $y_k\in Y$.
• Defuzzification: A crisp value for the output variable $y_k$ is derived from the membership function F at the defuzzification stage. Commonly, the center of gravity method is employed for this process.

The primary challenges associated with developing FISs are described in [6]:

• The representation of uncertainty: This challenge involves selecting the most suitable membership functions and their parameters, considering the specific characteristics of the data and the problem at hand [16,20,21].
• The evolving nature of algorithms: An FIS must be capable of adapting to variations in the input data to consider changes in the external environment and the object itself. One potential solution to this problem is the application of fuzzy clustering algorithms [9].
• Interpretability/explainability: The rules should contain the fewest possible conditions, and the total number of rules should be minimized to achieve a satisfactory quality level [4,5].
• Model optimization: This encompasses the previous challenges. Currently, an FIS’s hyperparameters are manually configured, which requires a deep understanding of the problem, its domain, and the mechanisms involved in the tuning of FISs [14,15,16,20,21].

In this paper, we focus on addressing these model optimization and interpretability/explainability challenges through the proposed fuzzy rule generation algorithm based on decision tree interpretation. This algorithm facilitates a reduction in both the number of rules and the number of conditions within those rules. The application of decision trees to improving the interpretability/explainability and generating a set of rules is extensively detailed in the literature. Related studies include leveraging decision trees to interpret fuzzy clustering results [22], the automatic generation of membership functions and tuning their parameters [23], the creation of fuzzy rule sets [24,25], and the automated construction of FISs through a data analysis [26]. Generally, these studies have been based on statistical techniques for data analysis and decision tree training based on fuzzified data.

Given the focus of this research, we are particularly interested in addressing the generation of fuzzy rule sets through decision tree interpretation, specifically exploring methods for simplifying the rules and decreasing their number to enhance the interpretability and explainability of FRBSs while also reducing the time required for their creation.

This research introduces a novel perspective on the generation of fuzzy rules, focusing on a reduction in the number of rules and statements. The focus of this paper is primarily on decreasing the time required to generate fuzzy rules and enhancing the interpretability and explainability of the results.

This study explores the potential to generate fuzzy rules derived from interpreting a decision tree model, even without expert knowledge in a specific domain. The proposed algorithm applies across various domains, allowing for the generation of a set of fuzzy rules for building an FRBS that addresses a wide range of tasks. Additionally, we will examine how the quality of the dataset affects the quality of the resulting FRBS.

The main aim of this study is to validate the following hypotheses:

 Hypothesis 1.

The proposed algorithm can generate a set of fuzzy rules for an FRBS based on the interpretation of the decision tree.

 Hypothesis 2.

The quality of the FRBS using the optimal parameters should not substantially decline when compared to that of the original decision tree model.

 Hypothesis 3.

The quality of the resulting FRBS is highly dependent on the quality of the dataset on which the decision tree is trained.

This paper is organized as follows: Section 2 provides an analysis of related works and the works from the current study scope. Section 3 presents a complete definition of a method for generating fuzzy rules for a fuzzy controller obtained from a decision tree. It also describes a detailed algorithm for generating fuzzy rules, along with a rule clustering algorithm that groups rules according to the parameters of their antecedent statements. Section 4 provides the experimental results, including examples of two FRBSs whose rule bases were created using the proposed method, and demonstrates the performance of these FRBSs.

2. Related Works

Google Scholar is used as the database in which to search for related works. Its search engine is of high quality, enabling users to filter articles for specific periods, view works by authors, and find related articles.

Table 1. Related work search parameters.

Topic	Keywords	Period
Fuzzy systems in control	“fuzzy systems” in control	From 2019
Trends and challenges in fuzzy system development	“fuzzy rule based systems” recent trends review
Challenges in the explainability of fuzzy systems	”fuzzy systems” explainability
Representation of knowledge and rules based on fuzzy logic	“fuzzy knowledge representation” “fuzzy rules”
Types of fuzzy logic	type-2 fuzzy systems review
Integration of fuzzy systems and neural networks	anfis “adaptive Neuro fuzzy inference system”
Hierarchical fuzzy systems	hierarchical fuzzy systems
Evolutionary fuzzy systems	evolutionary fuzzy systems
Selection of the optimal parameters for fuzzy systems	“membership functions” construction
Generation of fuzzy rules based on a decision tree	“decision tree” “fuzzy rules” generation

presents the parameters used for the related works search, including the topic, keywords, and period.

2.1. Fuzzy Systems in Control

At present, machine learning techniques, including deep neural networks, can address a wide range of control tasks with performance levels that are comparable to or exceed human capabilities. Nevertheless, for many challenges, fuzzy systems continue to be the preferred choice.

Fuzzy systems are based on fuzzy modeling, addressing approximation and classification tasks. One of the key advantages of fuzzy systems is their ability to represent the behavior of the modeled object through fuzzy rules, which can be interpreted by both humans and the systems themselves.

These systems provide the necessary level of transparency (often referred to as “white box” models) in scenarios where the cost of errors is significant. As a result, fuzzy systems offer a high degree of explainability: it is always possible to trace how a result was derived and to adjust the system’s behavior if an error is identified. Fuzzy systems are widely utilized in control problems across various application areas, such as [27] the following:

• Agriculture [28,29];
• Autonomous driving [30,31,32];
• Biomedical diagnostics [33,34,35];
• Energy system control [36,37,38,39];
• Fault diagnostics and detection [40,41,42];
• Financial time series prediction [43,44,45];
• Industrial control [46,47,48];
• Robotics [49,50,51];
• Weather forecasting [52,53,54], etc.

In the development of fuzzy systems, both classical architectures and those that combine fuzzy logic principles with machine learning techniques are employed, such as neural networks and reinforcement learning. This integration leverages the strengths of each approach while ensuring a satisfactory level of explainability for the system’s results.

2.2. Evolving Fuzzy Systems

To address the challenges associated with constructing fuzzy systems, methods for developing evolving fuzzy systems are employed [55,56]. The learning mechanism of the evolving fuzzy systems relies on analyzing data streams and adjusting the system in response to data changes. In this context, both the system’s structure and its parameters may evolve.

The architecture of a standard evolving fuzzy system comprises two main components:

• Updating the system parameters;
• Evolving the structure.

The structure-evolving component is dedicated to the creation, modification, and deletion of fuzzy rules based on changes in the data being processed. Initially, the knowledge base of such a system is empty and is populated during the learning phase by analyzing incoming data. Generally, the generation of fuzzy rules is based on the following methods:

• The density/potential criterion [57,58];
• The distance criterion [59,60];
• The error criterion [55,61];
• The firing strength criterion [62];
• The statistical contribution criterion [63].

The basis of the rule generation methods described above relies on clustering the observations (data) and subsequently converting the centers of these clusters into rules. In addition, different machine learning models or statistical analysis techniques can be employed to evaluate the importance of these rules.

The analysis of related works indicates that data can serve as a basis for generating fuzzy rules within a fuzzy system. In addition, machine learning techniques can aid in the creation of these fuzzy rules. Subsequently, fuzzy rules are developed based on the hidden patterns identified in the data.

2.3. Fuzzy Logic Types

Various types of fuzzy logic are used to develop fuzzy systems [64]:

• Type-1 fuzzy logic;
• Type-2 fuzzy logic;
• Interval type-2 fuzzy logic, etc.

Type-2 fuzzy logic extends traditional type-1 fuzzy logic to manage uncertainty better [65]. Type-2 fuzzy sets allow for the integration of uncertainty regarding the membership function within fuzzy set theory, directly addressing the limitations associated with type-1 fuzzy sets. In type-1 fuzzy systems, the membership function remains constant, whereas type-2 fuzzy systems feature a variable membership function. A fuzzy set plays a crucial role in transforming input values into fuzzy variables.

The advantage of using type-2 fuzzy logic lies in its enhanced flexibility in representing and managing uncertainty. Numerous studies have demonstrated that type-2 fuzzy logic can enhance the performance of fuzzy systems [66,67,68]. Nonetheless, there are several drawbacks associated with type-2 fuzzy logic that complicate its application when compared to type-1 fuzzy logic, including increased computational expenses and greater complexity in configuring the parameters of a fuzzy system. While this study does not focus on other types of fuzzy logic beyond type-1, it presents an opportunity to illustrate the principles of the proposed method for generating fuzzy rules based on the decision tree interpretation.

2.4. Fuzzy Rule Generation

Several studies are closely related to our work. The paper [23] describes an approach to the generation of fuzzy rules through an analysis of a decision tree created using the ID3 algorithm applied to the data after fuzzification. However, this work does not detail the algorithm for rule generation and does not address the simplification of or reductions in the rule number. In paper [24], an approach is discussed to developing an FIS for time series forecasting, where a set of rules is derived from the analysis of time series data after fuzzification. This paper similarly neglects to consider a reduction in or simplification of the rules. The work in [25] presents a method for constructing an FIS focused on predicting diabetes diagnoses, generating fuzzy rules based on a decision tree created using the C4.5 algorithm, again focusing on the data analyzed after fuzzification. Like previous studies, it lacks a detailed description of the rule generation algorithm and does not explore rule simplification or reduction. In [26], a methodology is described for the automatic generation of an FIS for ischemic and arrhythmic beat classification, where fuzzy rules are constructed from a decision tree derived from crisp data using the C4.5 algorithm. Although the number of rules is reduced on the basis of an author-proposed metric, this paper does not explicitly address reductions in the rule number.

In this study, we introduce a novel approach to generating fuzzy rules to construct an FRBS through the interpretation of decision trees. To obtain the initial set of rules, we extract them from the decision tree, similar to the methodologies in [23,24,25,26]. Then, we proceed with steps to simplify the statements of the rules and reduce their number. Following this, we perform fuzzification for the generated rules, also applying rule reduction at this stage. In addition, we provide a series of experiments to evaluate the effectiveness of our proposed approach.

3. Materials and Methods

In the previous section, we provided an analysis of articles that address the challenge of generating fuzzy rules for FRBSs. Traditionally, the development of a fuzzy rule set for a control system requires extensive expert knowledge from an analyst.

In this paper, we introduce an approach to generating fuzzy rules for an FRBS by analyzing the results of a supervised learning algorithm that relies on decision trees.

3.1. Schema of the Proposed Approach

We used the dataset described in [69] to obtain fuzzy rules extracted from the trained decision tree model. In [70], the authors used this dataset to construct and evaluate a GFS.

This dataset was selected for several reasons:

• The dataset represents stable physical processes that remain unaffected by external variables;
• The dataset is initially high-quality, eliminating the need for additional time spent on data preparation;
• The dataset is compact and contains a limited number of features, which streamlines the development and debugging of the fuzzy rule generation algorithm.

The dataset comprises multiple tables, with each detailing the impact of varying concentrations of aluminum oxide and titanium dioxide dispersed in a 50:50 volumetric proportion of distilled water and ethylene glycol on the density and viscosity parameters at different temperatures. The datasets are presented in Appendix A and Appendix B. Each dataset is divided into training and test sets.

Figure 2 illustrates the schema for extracting the fuzzy rules to develop an FRBS based on interpreting the outcomes of the decision tree.

As depicted in Figure 2, the input data are the training set for each parameter: density and viscosity.

The CART algorithm [71] was selected to train a binary decision tree. This algorithm offers several advantages:

• There is no requirement to compute or choose various parameters to run the algorithm.
• There is no need to pre-select the features for analysis. The features are automatically chosen during model training based on the Gini index value.
• The algorithm effectively works with outliers, creating separate branches in the tree for the data that contain them.
• It provides a rapid training speed for the model.

In the context of generating fuzzy rules, the CART algorithm significantly simplifies constructing a decision tree for various tasks. This simplification occurs even in the absence of a comprehensive understanding of the specific of the domain and the modeling object.

A significant drawback of the CART algorithm is its reduced performance on datasets with numerous dependencies among the features. This issue is not addressed in this article and will be explored in future work.

The decision tree model is created after the CART algorithm is executed. The effectiveness of the decision tree model is evaluated using the $R^2$ metric [71]. This model is used as the input data for the proposed approach to generating fuzzy rules, resulting in the creation of a set of fuzzy rules. Then, FRBSs are automatically formed based on the obtained fuzzy rules. Membership functions and linguistic term labels are automatically generated for all input and output parameters.

The effectiveness of the FRBS is evaluated using the $R^2$ metric in the test set and is compared to the decision tree model to validate Hypothesis 1.

3.2. Description of Fuzzy System

A fuzzy system must be automatically created for the density parameter, as illustrated in the MATLAB Fuzzy Logic Toolbox notation (R2024b) [72] in Figure 3.

The input parameters X [69] are as follows:

• Temperature ($temp$): 20–70 °C;
• Al₂O₃ concentration ($al$): 0, 0.05, and 0.3 vol %;
• TiO₂ concentration ($ti$): 0, 0.05, and 0.3 vol %.

The output parameter Y [69] is density ($density$).

The FRBS is based on the Mamdani algorithm [73]. Triangular membership functions are used for the fuzzification of the input parameters and the defuzzification of the output parameter.

Figure 4, Figure 5, Figure 6, and Figure 7 illustrate the automatically generated fuzzy sets for the parameters $al$, $ti$, $temp$, and $density$, respectively.

The Automf algorithm from the scikit-fuzzy library [74] was used to create all the fuzzy sets described above. The number of linguistic terms was a hyperparameter for the proposed approach to generating fuzzy rules, and we determined its value through experimentation.

3.3. Description of the Approach to Generating Fuzzy Rules

In this subsection, we describe the proposed method for generating fuzzy rules, illustrated by the example of constructing an FRBS to evaluate the output parameter $density$ using the input parameters $temp$, $al$, and $ti$. The dataset is represented in

Table A1. The effect of the input parameters $temp$, $al$, and $ti$ on the output parameter $density$.

#	$\mathit{temp}$ (°C)	$\mathit{al}$ (%)	$\mathit{ti}$ (%)	$\mathit{density}$
training dataset
1	20	0	0	1.0625
2	25	0	0	1.05979
3	35	0	0	1.05404
4	40	0	0	1.05103
5	45	0	0	1.04794
6	50	0	0	1.04477
7	60	0	0	1.03826
8	65	0	0	1.03484
9	70	0	0	1.03182
10	20	0.05	0	1.08755
11	45	0.05	0	1.07105
12	50	0.05	0	1.0676
13	55	0.05	0	1.06409
14	65	0.05	0	1.05691
15	70	0.05	0	1.05291
16	20	0.3	0	1.18861
17	25	0.3	0	1.18389
18	30	0.3	0	1.1792
19	40	0.3	0	1.17017
20	45	0.3	0	1.16572
21	50	0.3	0	1.16138
22	55	0.3	0	1.15668
23	60	0.3	0	1.15233
24	70	0.3	0	1.14414
25	20	0	0.05	1.09098
26	25	0	0.05	1.08775
27	30	0	0.05	1.08443
28	35	0	0.05	1.08108
29	40	0	0.05	1.07768
30	60	0	0.05	1.06362
31	65	0	0.05	1.05999
32	70	0	0.05	1.05601
33	25	0	0.3	1.2186
34	35	0	0.3	1.20776
35	45	0	0.3	1.19759
36	50	0	0.3	1.19268
37	55	0	0.3	1.18746
38	65	0	0.3	1.178
testing dataset
1	30	0	0	1.05696
2	55	0	0	1.04158
3	25	0.05	0	1.08438
4	30	0.05	0	1.08112
5	35	0.05	0	1.07781
6	40	0.05	0	1.07446
7	60	0.05	0	1.06053
8	35	0.3	0	1.17459
9	65	0.3	0	1.14812
10	45	0	0.05	1.07424
11	50	0	0.05	1.07075
testing dataset
12	55	0	0.05	1.06721
13	20	0	0.3	1.22417
14	30	0	0.3	1.2131
15	40	0	0.3	1.20265
16	60	0	0.3	1.18265
17	70	0	0.3	1.17261

.

The proposed approach can be represented as a function $F^{rules}$:

$$F^{rules}:r^C\to r^F,$$

where $r^C$ represents a collection of rules obtained from a decision tree (crisp rules), and $r^F$ is a set of fuzzy rules produced by applying the proposed approach.

Formally, a crisp rule can be defined as

$$r_i^C:\mathrm{if}\left(x_1{\diamond }_1{v}_1\right)\mathrm{and}\left(x_2{\diamond }_1{v}_2\right)\mathrm{and}\dots \mathrm{and}\left(x_n{\diamond }_n{v}_n\right)\to y_1,$$

where $x_j\in X$ denotes the j-th input parameter; $v_j$ indicates the specific value of $x_j$; and ${\diamond }_j\in [\le ,>,=]$ represents the relationship between the input parameter $x_j$ and its corresponding value $v_j$.

The fuzzy rule is defined in Equation (1).

The process of generating a set of fuzzy rules $r^F$ from the crisp rules $r^C$ using the function $F^{rules}$ consists of the following steps:

Step 1.

Extracting raw rules from the decision tree. The initial stage involves obtaining a set of raw rules $r^{raw}$ from the decision tree. The set $r^{raw}$ contains crisp rules.

Step 2.

Normalizing the raw rules. A set of normalized rules, called $r^{norm}$, is derived from the raw rules $r^{raw}$. This step requires eliminating any overlapping statements across all input parameters X to form a normalized rule $r_i^{norm}$ from the raw rule $r_i^{raw}$. The set $r^{norm}$ contains crisp rules.

Step 3.

Reducing similar rules. Some normalized rules in $r^{norm}$ may have identical antecedents but different consequents. These rules are classified as similar and should be reduced into a single rule, forming a set of reduced rules denoted as $r^{rnorm}$. The set $r^{rnorm}$ contains crisp rules.

Step 4.

Simplifying rules. This step involves transitioning from multiple statements in the antecedents of the rules associated with a specific input parameter $x_j$ that use the relations > and ≤ to a single statement with the relation =, which is essential for the construction of fuzzy rules. A set of simplified rules $r^{simp}$ is created from the set of reduced rules $r^{rnorm}$. The set $r^{simp}$ consists of crisp rules.

Step 5.

Fuzzifying rules. It is important to define fuzzy sets for the input parameters X and the output parameters Y to fuzzify the set of rules $r^{simp}$. This step generates a collection of raw fuzzy rules $r^{fraw}$ based on the simplified rules $r^{simp}$. The set $r^{fraw}$ contains fuzzy rules.

Step 6.

Reducing similar fuzzy rules. After the previous step, there may be fuzzy rules with similar antecedents but different consequents. In this step, similar fuzzy rules are reduced from the set $r^{fraw}$ to arrive at the final collection of fuzzy rules $r^{fuzz}$.

Figure 8 illustrates the steps involved in the proposed approach to generating fuzzy rules based on the interpretation of the decision tree.

Now, let us examine the steps of the proposed approach in greater detail.

3.4. Steps of the Approach to Generating Fuzzy Rules

Step 1.

Extracting raw rules from the decision tree

The set of raw rules $r^{raw}$ is extracted from the decision tree in the initial stage of the proposed approach. The extraction of a set of raw rules is performed using the algorithm defined in [75].

A raw rule extracted from a decision tree may include an excessive number of overlapping statements. For example,

$$\begin{array}{cc}& \mathrm{if}(al\le 0.175)\mathrm{and}(ti\le 0.175)\mathrm{and}(temp>32.5)\hfill \\ & \mathrm{and}(ti\le 0.025)\mathrm{and}(al\le 0.025)\mathrm{and}(temp>55.0)\hfill \\ & \mathrm{and}(temp>62.5)\to 1.033\hfill \end{array}$$

The complete set of raw rules $r^{raw}$ can be found in Appendix C.

Step 2.

Normalization of the raw rules

In the second step of the proposed approach, a set of normalized rules $r^{norm}$ is created from the set of raw rules $r^{raw}$. It is essential to erase any overlapping statements across all of the input parameters X to obtain a normalized rule $r_i^{norm}$ from the raw rule $r_i^{raw}$. The normalization process can be described by the algorithm described in Algorithm 1.

Algorithm 1 generates the set of normalized rules $r^{norm}$. The complete set of normalized rules is available in Appendix D. Below is an example of a normalized rule:

$$\begin{array}{cc}& \mathrm{Raw}\mathrm{rule}:\hfill \\ & \mathrm{if}(al\le 0.175)\mathrm{and}(ti\le 0.175)\mathrm{and}(temp>32.5)\hfill \\ & \mathrm{and}(ti\le 0.025)\mathrm{and}(al\le 0.025)\mathrm{and}(temp>55.0)\hfill \\ & \mathrm{and}(temp>62.5)\to 1.033\hfill \end{array}$$

$$\begin{array}{cc}& \mathrm{Normalized}\mathrm{rule}:\hfill \\ & \mathrm{if}(al\le 0.175)\mathrm{and}(ti\le 0.175)\mathrm{and}(temp>32.5)\to 1.033\hfill \end{array}$$

Step 3.

Reducing similar rules

Some normalized rules may have equivalent antecedents but different consequents. We refer to these as similar rules, which should be reduced to a single rule. Algorithm 2 formally describes the process of reducing similar rules.

Algorithm 1 Normalization algorithm

Input: Set of raw rules $r^{raw}=\{r_1^{raw},\dots ,r_n^{raw}\}$ extracted from a decision tree and consisting of N rules. Set of input parameters X. Output: Set of normalized rules $r^{norm}$. for all  $r_i^{raw}\in r^{raw}$  do     Create a new normalized rule $r_i^{norm}$.     for all $x_j\in X$ do         Obtain the statements s for an input parameter $x_j$ from the antecedent of the rule $r_i^{raw}$.         Select from s a statement $s_{min}$ with ${\diamond }_k\mathrm{is}>$ and the minimal value $v_k$: $$s_{min}=s_k\in s|{\diamond }_k\mathrm{is}>,v_k\to min.$$         Select from s a statement $s_{max}$ with ${\diamond }_k\mathrm{is}\le$ and the maximal value $v_k$: $$s_{max}=s_k\in s|{\diamond }_k\mathrm{is}\le ,v_k\to max.$$         Add statements $s_{min}$ and $s_{max}$ to the antecedent of the new rule $r_i^{norm}$.     end for     Add the consequent of the i-th raw rule $r_i^{raw}$ to the new rule $r_i^{norm}$.     Add the new rule $r_i^{norm}$ to the set of normalized rules $r^{norm}$. end for return  $r^{norm}$

Algorithm 2 Reducing algorithm

Input: Set of normalized rules $r^{norm}=\{r_1^{norm},\dots ,r_n^{norm}\}$ consisting of N rules. Output: Set of normalized rules $r^{rnorm}$ after removing similar rules (reducing them). Obtain the set of similar rules $r^{sim}$. Add the rules that are not present in the set $r^{sim}$ to the set $r^{rnorm}$. for all  $r_i^{sim}\in r^{sim}$  do     Select the rules r whose antecedent matches that of the i-th rule $r_i^{sim}$ from the set of similar rules $r^{sim}$.     Create a new rule $r_i^{rnorm}$ by aggregating the rules r and applying the averaging function to the values of the output parameter $y_i$ in the consequent $$y_i=\mathrm{avg}\left(y_1^r,\dots ,y_m^r\right).$$     Add the new rule $r_i^{rnorm}$ to the set $r^{rnorm}$. end for return  $r^{rnorm}$

The following example illustrates the execution of Algorithm 2:

$$\begin{array}{cc}& \mathrm{Before}\mathrm{reducing}\mathrm{similar}\mathrm{rules}:\hfill \\ & \mathrm{if}(al\le 0.175)\mathrm{and}(ti\le 0.175)\mathrm{and}(temp>32.5)\mathrm{and}(temp\le 55.0)\to 1.045\hfill \\ & \mathrm{if}(al\le 0.175)\mathrm{and}(ti\le 0.175)\mathrm{and}(temp>32.5)\mathrm{and}(temp\le 55.0)\to 1.051\hfill \end{array}$$

$$\begin{array}{cc}& \mathrm{After}\mathrm{reducing}\mathrm{similar}\mathrm{rules}:\hfill \\ & \mathrm{if}(al\le 0.175)\mathrm{and}(ti\le 0.175)\mathrm{and}(temp>32.5)\mathrm{and}(temp\le 55.0)\to 1.048\hfill \end{array}$$

The set of normalized rules $r^{norm}$ comprises 34 rules ($|r^{norm}|=34$), while the resulting reduced set $r^{rnorm}$ comprises 24 rules ($|r^{rnorm}|=24$). The complete set $r^{rnorm}$ is detailed in Appendix E.

Step 4.

Simplifying rules

Next, we need to make the transition from multiple statements of the antecedents of the rules belonging to a specific input parameter $x_j$ with the relations > and ≤ to a single statement with the relation =. It is necessary to construct fuzzy rules.

The rule simplification algorithm is based on the analysis of the statements for each input parameter $x_j$. It is essential to determine the left n and right m boundaries of the interval for each input parameter $x_j$ with the relations > and ≤, respectively, in each i-th rule $r_i^{rnorm}$. Next, the maximum value for each interval must be identified, considering the chosen membership function. For example, we seek the center of the base of a triangle for a triangular membership function. We apply the avg function if the interval includes the left n and right m boundaries. We use the min function if it only has a left boundary n. Otherwise, we apply the max function. Figure 9 illustrates this schema.

The process of simplifying rules can be structured as described in Algorithm 3.

Let us examine an example of simplified rules:

$$\begin{array}{cc}& \mathrm{Before}:\hfill \\ & \mathrm{if}(al\le 0.175)\mathrm{and}(ti\le 0.175)\mathrm{and}(temp>32.5)\to 1.033\hfill \\ & \mathrm{After}:\hfill \\ & \mathrm{if}(al=0.0)\mathrm{and}(ti=0.0)\mathrm{and}(temp=70)\to 1.033\hfill \end{array}$$

$$\begin{array}{cc}& \mathrm{Before}:\hfill \\ & \mathrm{if}(al\le 0.175)\mathrm{and}(ti\le 0.175)\mathrm{and}(temp>32.5)\mathrm{and}(temp\le 62.5)\to 1.038\hfill \\ & \mathrm{After}:\hfill \\ & \mathrm{if}(al=0.0)\mathrm{and}(ti=0.0)\mathrm{and}(temp=47.5)\to 1.038\hfill \end{array}$$

A complete set of simplified rules $r^{simp}$ can be found in Appendix F.

Algorithm 3 Simplifying rule algorithm

Input: Reduced set of normalized rules $r^{rnorm}=\{r_1^{rnorm},\dots ,r_n^{rnorm}\}$ consisting of N rules. Set of input parameters X. Training set for a decision tree learning $data$. Output: Set of simplified rules $r^{simp}$. for all  $r_i^{rnorm}\in r^{rnorm}$  do     Create a new rule $r_i^{simp}$.     for all $x_j\in X$ do         Obtain the statements s from the antecedent of the rule $r_i^{rnorm}$ that describe the left n and right m boundaries of the input parameter $x_j$: $$n=\left\{\begin{array}{cc}{s}_k\hfill & \mathrm{if}\exists s_k\in s\mathrm{s}.\mathrm{t}.{\diamond }_k\mathrm{is}>\hfill \\ \varnothing \hfill & \mathrm{otherwise}\hfill \end{array}\right.m=\left\{\begin{array}{cc}{s}_k\hfill & \mathrm{if}\exists s_k\in s\mathrm{s}.\mathrm{t}.{\diamond }_k\mathrm{is}\le \hfill \\ \varnothing \hfill & \mathrm{otherwise}\hfill \end{array}\right.$$         Calculate a new value for a single statement: $$value=\left\{\begin{array}{cc}\mathrm{avg}\left(valu{e}^n,valu{e}^m\right)\hfill & \mathrm{if}\exists n\mathrm{and}\exists m\hfill \\ min\left(data\left[x_j\right]\right)\hfill & \mathrm{if}\exists n\mathrm{and}\nexists m\hfill \\ max\left(data\left[x_j\right]\right)\hfill & \mathrm{otherwise}\hfill \end{array}\right..$$         Create a new statement $s_j(x_j=value)$ and add them to the antecedent of the new rule $r_i^{simp}$.     end for     Add the new rule $r_i^{simp}$ to the set of simplified rules $r^{simp}$. end for return  $r^{simp}$

Step 5.

Fuzzifying rules

It is necessary to define fuzzy sets for the input parameters X and the output parameters Y for the fuzzification of the rule set $r^{simp}$. The automatic method described in [74] applies to generating fuzzy sets for crisp parameters as implementing the function $F^{fuzz}$:

$$\begin{array}{c}\hfill F^{fuzz}:x_i\times n\to A_i,x_i\in X,A_i={\int }_U{\mu }_A\left(x_i\right)/x_i,\\ \hfill F^{fuzz}:y_j\times n\to C_j,y_j\in Y,C_j={\int }_U{\mu }_A\left(y_j\right)/x_j.\end{array}$$

This process results in the formation of the corresponding fuzzy sets with a specified number of linguistic terms n for each input and output parameter.

Subsequently, Algorithm 4 generates a collection of raw fuzzy rules $r^{fraw}$ based on the simplified rule set $r^{simp}$.

Let us examine an example of fuzzy rules:

$$\begin{array}{cc}& \mathrm{Before}:\hfill \\ & \mathrm{if}(al=0.0)\mathrm{and}(ti=0.0)\mathrm{and}(temp=70)\to 1.033\hfill \\ & \mathrm{After}:\hfill \\ & \mathrm{if}\left(al\mathrm{is}low\right)\mathrm{and}\left(ti\mathrm{is}low\right)\mathrm{and}\left(temp\mathrm{is}high\right)\to \left(density\mathrm{is}lower\right)\hfill \end{array}$$

Step 6.

Reducing similar fuzzy rules

Rules with similar antecedents but differing consequents may be produced after executing Algorithm 4. Algorithm 5 is used to reduce these similar fuzzy rules.

Algorithm 4 Fuzzifying rule algorithm

Input: Set of simplified rules $r^{simp}=\{r_1^{simp},\dots ,r_n^{simp}\}$ consisting of N rules. Hyperparameters H to specify the number of linguistic terms n for the fuzzification of the input X and output Y parameters. Output: Set of raw fuzzy rules $r^{fraw}$. for all  $r_i^{simp}\in r^{simp}$  do     Create a new rule $r_i^{fraw}$.     Obtain the statements s from the antecedent of the i-th rule $r_i^{fraw}$.     for all $s_j\in s$ do         Fuzzify the value of the j-th statement and select the fuzzy value with the maximal membership degree: $$\begin{array}{c}{A}_j=F^{fuzz}(s_j,H)\hfill \\ a^{max}=arg\underset{a\in A_j}{max}\left({\mu }_A\left(s_j\right)\right)\hfill \end{array}$$         Create a new statement $s_j^{fuzz}\left(x_j\mathrm{is}{a}^{max}\right)$ and add it to the antecedent of the new rule $r_i^{fraw}$.     end for     Fuzzyfy the value of the consequent $y_i$ and select the fuzzy value with maximal membership degree: $$\begin{array}{c}{C}_i=F^{fuzz}(y_i,H)\hfill \\ c^{max}=arg\underset{c\in C_i}{max}\left({\mu }_A\left(y_i\right)\right)\hfill \end{array}$$     Add a statement $s_i^{fuzz}\left(y_i\mathrm{is}{c}^{max}\right)$ as a consequent of the new rule $r_i^{fraw}$.     Add the new rule $r_i^{fraw}$ to the set of raw fuzzy rules $r^{fraw}$. end for return  $r^{fraw}$

Algorithm 5 Reducing similar fuzzy rule algorithm

Input: Set of raw fuzzy rules $r^{fraw}=\{r_1^{fraw},\dots ,r_n^{fraw}\}$ consisting of N rules. Output: Reduced set of fuzzy rules $r^{fuzz}$ after removing similar rules. Obtain the set of similar rules $r^{sim}$. Add the rules that are not present in the set $r^{sim}$ to the set $r^{fuzz}$. for all  $r_i^{sim}\in r^{sim}$  do     Obtain the rules r whose antecedent matches that of the i-th rule $r_i^{sim}$ from the set of similar rules $r^{sim}$.     Select the rule $r^{min}$ from the set of rules r for which the sum of the membership degrees of the statements in the rule antecedent is minimal: $$r^{min}=arg\underset{r_i\in r}{min}\left(\sum _{j=1}^n{\mu }_A\left(x_{ij}\right)\right)$$     Add the rule $r^{min}$ to the set $r^{fuzz}$. end for return $r^{fuzz}$

The resulting reduced set of fuzzy rules $r^{fuzz}$ is detailed in Appendix G. Initially, there are 24 rules in the set before fuzzification ($|r^{simp}|=24$), which are reduced to 15 rules ($|r^{fuzz}|=15$) after fuzzification and the removal of similar rules.

Once the set of fuzzy rules is established, fuzzy inference can be executed to obtain the values of the output parameters Y based on the input parameters X.

3.5. Rule Clustering

Rule clustering allows the grouping of rules according to the parameters found in the antecedent statements of these rules. These groups simplify expert evaluation of the rules and the tuning of the hyperparameters to the proposed fuzzy rule generation method. The rule clustering algorithm presented here applies to both crisp and fuzzy rules.

For example, groups can be identified as rows 1 to 9, 10 to 15, etc. in the dataset referenced in Table A1. A specific set of input parameters must be defined to cluster the rules. The antecedent statements of the rules are chosen on the basis of these parameters. Clustering of the dataset in Table A1 can be performed using the parameters $al$ and $ti$, while the parameter $temp$ can be ignored since its value is consistently repeated in all data groups.

This process results in the formation of a unique set of statements s:

$$\begin{array}{c}\hfill s=\left\{\right(al\le 0.175),(al>0.025),(al>0.175),(ti\le 0.175),(ti>0.025),(ti>0.175\left)\right\}.\end{array}$$

The rules need to be vectorized for clustering. The set s is used as a binary mask for vectorization. For example, the rule $r_1^{norm}\in r^{norm}$ results in the vector $v_1^{norm}$:

$$\begin{array}{cc}& r_1^{norm}:\mathrm{if}(al\le 0.175)\mathrm{and}(ti\le 0.175)\mathrm{and}(temp>32.5)\to 1.033\hfill \\ & v_1^{norm}=\langle 1,0,0,1,0,0\rangle .\hfill \end{array}$$

Once vectorization is complete, the next step is to automatically determine the number of clusters. The minimum number of clusters is set at $k^{min}=2$, while the maximum can be provided by the user or calculated as $k^{max}=\sqrt{\left|r^{norm}\right|}+1$. The automatic selection of the number of clusters relies on the silhouette score s [76]:

$$s={\displaystyle \frac{b-a}{max\left(a,b\right)}},$$

where a is the mean intra-cluster distance; b is the distance between a sample and the nearest cluster that the sample is not a part of. The best value is 1, and the worst value is $-1$. Values near 0 indicate overlapping clusters. Negative values indicate that a sample has been assigned to the wrong cluster, as a different cluster is more similar.

The KMeans algorithm is used for clustering. The KMeans algorithm was selected due to its rapid performance. To address the challenge of determining the optimal number of clusters, the silhouette score was utilized. This metric was preferred due to the simplicity of its implementation and its ability to programmatically determine the optimal number of clusters.

The proposed algorithm performs n iterations for each $k_i\in 〚k^{min},k^{max}〛$. The silhouette score $s_i$ is calculated (Figure 10) for each iteration $k_i$, and the iteration showing the minimum number of clusters ($k_i$) with the highest value $s_i$ is selected. In this case, the optimal $s_i$ value was achieved during iteration $i=4$, resulting in a division into five clusters.

The result of the rule clustering is as follows:

$$\begin{array}{cc}& \mathrm{Cluster}1:\hfill \\ & \mathrm{if}(al\le 0.175)\mathrm{and}(ti\le 0.175)\mathrm{and}(temp>32.5)\to 1.033\hfill \\ & \dots \hfill \\ & \mathrm{if}(al\le 0.175)\mathrm{and}(ti\le 0.175)\mathrm{and}(temp\le 32.5)\to 1.062\hfill \\ & \dots \hfill \end{array}$$

$$\begin{array}{cc}& \mathrm{Cluster}3:\hfill \\ & \mathrm{if}(al\le 0.175)\mathrm{and}(ti\le 0.175)\mathrm{and}(ti>0.025)\mathrm{and}(temp>32.5)\to 1.056\hfill \\ & \dots \hfill \\ & \mathrm{if}(al\le 0.175)\mathrm{and}(ti\le 0.175)\mathrm{and}(ti>0.025)\mathrm{and}(temp\le 32.5)\to 1.091\hfill \\ & \dots \hfill \end{array}$$

The complete results of the rule clustering can be found in Appendix H.

4. Experiments

We developed an application to validate our hypotheses. The primary parameters of the environment for this application are as follows:

• Programming language: Python.
• Python interpreter version: 3.12.
• Libraries:
  • Machine learning library (including the CART decision trees and KMeans clustering): scikit-learn 1.5.2;
  • Data manipulation libraries: numpy 2.1.0 and pandas 2.2.2;
  • Fuzzy inference library: scikit-fuzzy 0.5.0;
  • Plotting library: matplotlib 3.9.2;
  • Additional dependency for the scikit-fuzzy library: networkx 3.4.2.

4.1. Hypothesis 1 Validation

To evaluate Hypothesis 1, we developed three FRBSs. We used the dataset described in [69] to obtain the fuzzy rules extracted from the decision tree model.

The dataset comprises multiple tables, with each detailing the impact of varying concentrations of aluminum oxide and titanium dioxide dispersed in a 50:50 volumetric proportion of distilled water and ethylene glycol on the density and viscosity parameters at different temperatures. The datasets are presented in Appendix A and Appendix B. Each dataset is split into training and test sets.

Three FRBSs were developed for the parameters of density, viscosity, and temperature, respectively. All of the systems are illustrated in Figure 11 using the MATLAB Fuzzy Toolbox notation.

Figure 4, Figure 5, Figure 6, Figure 7, Figure 12, Figure 13, and Figure 14 illustrate the automatically generated fuzzy sets for the parameters $al$, $ti$, $temp$ (as the input parameters for the density FRBS with $n=3$), $density$, $temp$ (with $n=5$ as the input parameter for the viscosity FRBS and the output parameter for the temperature FRBS), $viscosity$ (with $n=5$ as the output parameter for the viscosity FRBS), and $viscosity$ (with $n=3$ as the input parameter for the temperature FRBS), respectively.

Decision tree models were constructed for the output parameter $density$ using the training set from the dataset in Table A1, and the output parameters $viscosity$ and $temp$ were modeled using the dataset from

Table A2. The effect of the input parameters $temp$, $al$, and $ti$ on the output parameter $viscosity$.

#	$\mathit{temp}$ (°C)	$\mathit{al}$ (%)	$\mathit{ti}$ (%)	$\mathit{density}$
training dataset
1	20	0	0	3.707
2	25	0	0	3.18
3	35	0	0	2.361
4	45	0	0	1.832
5	50	0	0	1.629
6	55	0	0	1.465
7	70	0	0	1.194
8	20	0.05	0	4.66
9	30	0.05	0	3.38
10	35	0.05	0	2.874
11	40	0.05	0	2.489
12	50	0.05	0	1.897
13	55	0.05	0	1.709
14	60	0.05	0	1.47
15	20	0.3	0	6.67
16	25	0.3	0	5.594
17	30	0.3	0	4.731
18	35	0.3	0	4.118
19	40	0.3	0	3.565
20	55	0.3	0	2.426
21	60	0.3	0	2.16
22	70	0.3	0	1.728
23	20	0	0.05	4.885
24	25	0	0.05	4.236
25	35	0	0.05	3.121
26	40	0	0.05	2.655
27	45	0	0.05	2.402
28	50	0	0.05	2.109
29	60	0	0.05	1.662
30	70	0	0.05	1.289
31	20	0	0.3	7.132
32	25	0	0.3	5.865
33	30	0	0.3	4.944
34	35	0	0.3	4.354
35	45	0	0.3	3.561
36	55	0	0.3	2.838
37	60	0	0.3	2.538
38	70	0	0.3	1.9097
testing dataset
1	30	0	0	2.716
2	40	0	0	2.073
3	60	0	0	1.329
4	65	0	0	1.211
5	25	0.05	0	4.12
6	45	0.05	0	2.217
7	65	0.05	0	1.315
8	70	0.05	0	1.105
9	45	0.3	0	3.111
10	50	0.3	0	2.735
11	65	0.3	0	1.936
12	30	0	0.05	3.587
13	55	0	0.05	1.953
14	65	0	0.05	1.443
15	40	0	0.3	3.99
16	50	0	0.3	3.189
17	65	0	0.3	2.287

. The input parameters for the density and viscosity FRBSs included $al$, $ti$, and $temp$, whereas the input parameters for the temperature FRBS consisted of $al$, $ti$, and $viscosity$.

The following $R^2$ metric values were calculated for the resulting decision tree models using the test set from the datasets in Table A1 and Table A2:

• $R_{density}^2=0.99$;
• $R_{viscosity}^2=0.83$;
• $R_{temp}^2=0.76$.

The following raw rules were extracted from the decision trees:

• $\left|r_{density}^{raw}\right|=34$;
• $\left|r_{viscosity}^{raw}\right|=35$;
• $\left|r_{temp}^{raw}\right|=25$.

The following raw rules were obtained after applying normalization and removing similar rules (reducing them):

• $\left|r_{density}^{norm}\right|=24$;
• $\left|r_{viscosity}^{norm}\right|=26$;
• $\left|r_{temp}^{norm}\right|=17$.

Subsequently, the proposed algorithm generated the following fuzzy rules:

• $\left|r_{density}^{fuzz}\right|=15$;
• $\left|r_{viscosity}^{fuzz}\right|=19$;
• $\left|r_{temp}^{fuzz}\right|=11$.

Fuzzy inference implements the calculation of the crisp output parameters Y from the crisp input parameters X. Fuzzy rules are used in the inference process to represent expert knowledge as the functional relationship $F:X\to Y$.

For example, for the density FRBS, the steps of fuzzy inference are as follows for the input parameters $al=0$, $ti=0$, and $temp=25$:

• Fuzzification:
  • ${\mu }_{low}\left(al\right)=1.0$, ${\mu }_{average}\left(al\right)=0.0$, ${\mu }_{high}\left(al\right)=0.0$;
  • ${\mu }_{low}\left(ti\right)=1.0$, ${\mu }_{average}\left(ti\right)=0.0$, ${\mu }_{high}\left(ti\right)=0.0$;
  • ${\mu }_{low}\left(temp\right)=0.8$, ${\mu }_{average}\left(temp\right)=0.2$, ${\mu }_{high}\left(temp\right)=0.0$.
• Aggregation and activation:
  • For rule
    $\mathrm{if}\left(al\mathrm{is}low\right)\mathrm{and}\left(ti\mathrm{is}low\right)\mathrm{and}\left(temp\mathrm{is}average\right)\to \left(density\mathrm{is}lower\right)$
    ${\delta }_1^A=min\{1.0,1.0,0.2\}=0.2$
    ${\delta }_1^C={\delta }_1^A=0.2$;
  • For rule
    $\mathrm{if}\left(al\mathrm{is}low\right)\mathrm{and}\left(ti\mathrm{is}low\right)\mathrm{and}\left(temp\mathrm{is}low\right)\to \left(density\mathrm{is}low\right)$
    ${\delta }_2^A=min\{1.0,1.0,0.8\}=0.8$
    ${\delta }_2^C={\delta }_2^A=0.8$;
  • For rule
    $\mathrm{if}\left(al\mathrm{is}high\right)\mathrm{and}\left(temp\mathrm{is}average\right)\to \left(density\mathrm{is}high\right)$
    ${\delta }_3^A=min\{0.0,0.0,0.2\}=0.0$
    ${\delta }_3^C={\delta }_3^A=0.0$, etc.
• Accumulation. Figure 15 represents the accumulation result.
• Defuzzification. $density=1.076,$ and $density\in Y$.

Table 2. Experimental results.

#	$\mathit{temp}$ (°C) Viscosity (Pa·s)	$\mathit{al}$ (%)	$\mathit{ti}$ (%)	Real	Inferred	RMSE
Density FRBS
1	30	0	0	1.056	1.073	0.017
2	55	0	0	1.041	1.047	0.006
3	25	0.05	0	1.084	1.076	0.008
4	30	0.05	0	1.081	1.073	0.007
5	35	0.05	0	1.077	1.069	0.009
6	40	0.05	0	1.074	1.067	0.007
7	60	0.05	0	1.061	1.067	0.007
8	35	0.3	0	1.174	1.172	0.002
9	65	0.3	0	1.148	1.136	0.012
10	45	0	0.05	1.074	1.067	0.007
11	50	0	0.05	1.071	1.067	0.004
12	55	0	0.05	1.067	1.068	0.001
13	20	0	0.3	1.224	1.204	0.020
14	30	0	0.3	1.213	1.202	0.011
15	40	0	0.3	1.202	1.203	0.001
16	60	0	0.3	1.182	1.176	0.007
17	70	0	0.3	1.172	1.172	0.000
					Total	0.009
Viscosity FRBS
1	30	0	0	2.716	3.089	0.374
2	40	0	0	2.073	2.359	0.287
3	60	0	0	1.329	1.465	0.137
4	65	0	0	1.211	1.414	0.204
5	25	0.05	0	4.120	3.188	0.931
6	45	0.05	0	2.217	2.045	0.171
7	65	0.05	0	1.315	1.414	0.100
8	70	0.05	0	1.105	1.408	0.304
9	45	0.3	0	3.111	3.499	0.388
10	50	0.3	0	2.735	3.475	0.740
11	65	0.3	0	1.936	1.812	0.124
12	30	0	0.05	3.587	3.111	0.475
13	55	0	0.05	1.953	2.128	0.176
14	65	0	0.05	1.443	1.414	0.028
15	40	0	0.3	3.990	3.475	0.515
16	50	0	0.3	3.189	3.475	0.286
17	65	0	0.3	2.287	1.812	0.475
					Total	0.407
Temperature FRBS
1	2.716	0	0	30	48.540	18.540
2	2.073	0	0	40	51.739	11.739
3	1.329	0	0	60	58.696	1.304
4	1.211	0	0	65	63.509	1.491
5	4.120	0.05	0	25	30.269	5.269
6	2.217	0.05	0	45	52.190	7.190
Temperature FRBS
7	1.315	0.05	0	65	59.122	5.878
8	1.105	0.05	0	70	65.513	4.487
9	3.111	0.3	0	45	44.290	0.710
10	2.735	0.3	0	50	52.520	2.520
11	1.936	0.3	0	65	59.258	5.742
12	3.587	0	0.05	30	34.285	4.285
13	1.953	0	0.05	55	51.675	3.325
14	1.443	0	0.05	65	56.137	8.863
15	3.990	0	0.3	40	38.163	1.838
16	3.189	0	0.3	50	44.909	5.092
17	2.287	0	0.3	65	59.971	5.029
					Total	6.954

presents the test set used to evaluate the approximation ability of the constructed FRBSs. Each row lists the values of the input variables, $temp$, $al$, $ti$, and $viscosity$, along with the corresponding output parameter value in the Real column. The Inferred column displays the fuzzy inference results for each set of input parameters (row). The RMSE column shows the root mean square deviation between the values in the Real and Inferred columns.

The $R^2$ values for the FRBS were calculated using the test set from the datasets in Table A1 and Table A2:

• ${\tilde{R}}_{density}^2=0.97$;
• ${\tilde{R}}_{viscosity}^2=0.81$;
• ${\tilde{R}}_{temp}^2=0.75$.

We then calculated the difference in quality between the decision tree models and the FRBSs using the $R^2$ metric:

• ${\Delta }_{density}=R_{density}^2-{\tilde{R}}_{density}^2=0.014$;
• ${\Delta }_{viscosity}=R_{viscosity}^2-{\tilde{R}}_{viscosity}^2=0.025$;
• ${\Delta }_{temp}=R_{temp}^2-{\tilde{R}}_{temp}^2=0.014$.

The average difference in the $R^2$ metric is about 2%. Hypothesis 1 is proven.

4.2. Hypothesis 2 Validation

In this experiment, the slight difference in performance between the decision tree model and the FRBS can be attributed to the optimal selection of the parameters for the FRBS, including the membership function parameters, the number of terms, and the fuzzy rules.

To validate Hypothesis 2, we modified the number of linguistic terms to three for all fuzzy sets in all FRBSs.

Next, the $R^2$ values for the modified FRBS were calculated using the test sets:

• ${\overline{R}}_{density}^2=0.87$;
• ${\overline{R}}_{viscosity}^2=0.58$;
• ${\overline{R}}_{temp}^2=0.55$.

We subsequently determined the quality difference between the original and the modified FRBSs:

• ${\Delta }_{density}={\tilde{R}}_{density}^2-{\overline{R}}_{density}^2=0.10$;
• ${\Delta }_{viscosity}={\tilde{R}}_{viscosity}^2-{\overline{R}}_{viscosity}^2=0.23$;
• ${\Delta }_{temp}={\tilde{R}}_{temp}^2-{\overline{R}}_{temp}^2=0.20$.

We also determined the the quality difference between the decision tree models and the modified FRBSs:

• ${\Delta }_{density}=R_{density}^2-{\overline{R}}_{density}^2=0.12$;
• ${\Delta }_{viscosity}=R_{viscosity}^2-{\overline{R}}_{viscosity}^2=0.25$;
• ${\Delta }_{temp}=R_{temp}^2-{\overline{R}}_{temp}^2=0.21$.

The average difference in the $R^2$ metric between the original and modified FRBSs is about 18%, while it is about 19% between the decision tree models and the modified FRBSs. Hypothesis 2 is proven.

4.3. Hypothesis 3 Validation

To validate Hypothesis 3, we conducted an analysis of the datasets in Table A1 and Table A2.

Let us first examine the results from the analysis of the dataset in Table A2. We used the dataset in Table A2 to construct the viscosity FRBS and temperature FRBS.

As illustrated in Figure 16, there are no outliers present in the dataset. The lack of outliers minimizes the approximation errors, allowing for more accurate patterns during the modeling process.

Figure 17 demonstrates the strong inverse correlation between the temperature and viscosity features. The presence of this correlation enhances the performance of the temperature FRBS, bringing it in line with that of the decision tree model.

In addition, Figure 18 shows that the values of viscosity and temperature are well distributed across the entire solution space. Therefore, the dataset in Table A2 is qualitative.

Based on the findings from prior experiments, we can conclude that applying the proposed method for generating fuzzy rules to a qualitative dataset is effective. This approach allows for the creation of an FRBS with a satisfactory level of quality.

Now, let us examine the dataset in Table A1, which we used to develop the density FRBS.

Figure 19 shows that the dataset in Table A1 does not contain outliers either.

As illustrated in Figure 20, there is no correlation between the temperature feature and the al, ti, and density features. Consequently, constructing an FRBS to determine temperature based on the density value using the proposed rule generation algorithm may not be workable.

The fuzzy rule generation process targets minimizing both the number of rule conditions and the total number of rules. However, in the lack of a correlation between the input and output parameters, this simplification may significantly restrict the solution space.

Figure 21 demonstrates that the data distribution in the dataset in Table A1 may prevent the ability to achieve an acceptable level of approximation when calculating the temperature based on the density value. As a result, the quality of the FRBS produced will probably be lower than that of the decision tree model.

Figure 22 illustrates the temperature* FRBS represented using the MATLAB Fuzzy Logic Toolbox notation. This FRBS is designed for calculating the output parameter $temp$ using the input parameters $al$, $ti$, and $density$.

For all of the FRBS linguistic variables, three linguistic terms were automatically created using the triangular membership function. These parameters were selected because they resulted in the highest quality of the system.

The $R_{temp*}^2=0.77$ metric value was calculated for the resulting decision tree model using the test set from the datasets in Table A1.

The 27 raw rules were extracted from the decision tree: $\left|r_{temp*}^{raw}\right|=27$.

The 15 raw rules were obtained after applying normalization and removing similar rules (reducing them): $\left|r_{temp*}^{norm}\right|=15$.

Next, the proposed algorithm generated the eight fuzzy rules: $\left|r_{temp*}^{fuzz}\right|=8$.

Let us examine a set of generated fuzzy rules:

$$\begin{array}{cc}& \mathrm{if}\left(density\mathrm{is}low\right)\mathrm{and}\left(ti\mathrm{is}low\right)\mathrm{and}\left(al\mathrm{is}high\right)\to \left(temp\mathrm{is}high\right)\hfill \\ & \mathrm{if}\left(density\mathrm{is}low\right)\mathrm{and}\left(ti\mathrm{is}high\right)\to \left(temp\mathrm{is}high\right)\hfill \\ & \mathrm{if}\left(density\mathrm{is}low\right)\to \left(temp\mathrm{is}high\right)\hfill \\ & \mathrm{if}\left(density\mathrm{is}low\right)\mathrm{and}\left(ti\mathrm{is}low\right)\mathrm{and}\left(al\mathrm{is}low\right)\to \left(temp\mathrm{is}average\right)\hfill \\ & \mathrm{if}\left(density\mathrm{is}average\right)\mathrm{and}\left(al\mathrm{is}high\right)\to \left(temp\mathrm{is}low\right)\hfill \\ & \mathrm{if}\left(density\mathrm{is}average\right)\to \left(temp\mathrm{is}average\right)\hfill \\ & \mathrm{if}\left(density\mathrm{is}high\right)\mathrm{and}\left(al\mathrm{is}low\right)\to \left(temp\mathrm{is}low\right)\hfill \\ & \mathrm{if}\left(density\mathrm{is}high\right)\mathrm{and}\left(al\mathrm{is}high\right)\to \left(temp\mathrm{is}low\right)\hfill \end{array}$$

The ${\tilde{R}}_{temp*}^2=0.04$ value for the temperature* FRBS was calculated using the test set from the dataset in Table A1.

Figure 23 illustrates the distribution of both real and inferred values of the temperature parameter derived from the execution of the temperature* FRBS.

After disabling the stage of reducing similar rules, the number of fuzzy rules increased to 10, and the quality of the system was enhanced to ${\tilde{R}}_{temp*}^2=0.11$. The distribution of both the real and inferred values of the temperature parameter derived from the execution of the modified temperature* FRBS is illustrated in Figure 24.

Hypothesis 3 is proven.

5. Discussion

In this section, we describe the primary advantages, disadvantages, and limitations of the proposed approach to generating fuzzy rules based on the decision tree interpretation.

Our analysis of the related literature indicates that the FRBS balances interpretability and an acceptable quality level [4,5,6]. One key advantage of the proposed method is that it enables the construction of an FRBS without requiring an in-depth understanding of the domain, the task, or the analyzed object. This approach significantly reduces the time required to create an initial version of the FRBS, allowing for later improvements. Optimizing the parameters or modifying the fuzzy rule base enhances the system quality. Any existing method can be used to adjust the FRBS parameters. For example, genetic or evolutionary algorithms can be used for parameter optimization [6,7,8]. With the optimal parameters and a high-quality dataset, the resulting FRBS performs comparably to a decision tree model. The advantages of the proposed method compared to existing techniques for generating fuzzy rules from decision trees include the following [23,24,25,26]:

• This approach applies to a range of tasks because it is not limited to a specific domain or task;
• This article explains the fuzzy rule generation algorithm, complete with details and examples;
• This article includes experiments that show how the parameters and data quality affect the quality of the resulting FRBS.

However, there are some drawbacks to this approach. It lacks automatic adaptation to changes in data, unlike evolving fuzzy systems [27]. When generating rules, it does not consider various rule quality metrics that are typically employed in evolving fuzzy systems [27] and cognitive modeling methods [77]. In addition, the proposed method uses only type-1 fuzzy logic [65].

The limitations of the proposed approach include significant dependence on the quality of the dataset and the number of features. As the number of features increases, the complexity and quantity of rules rise, leading to longer operational times for the FRBS and a decline in its overall quality. The limitations of the proposed approach also include the ability to work with a dataset on which the CART algorithm shows an acceptable result. The proposed approach is suitable only for an FRBS based on the Mamdani algorithm.

6. Conclusions

This study presents a novelty in terms of the approach to generating a set of fuzzy rules with a subsequent reduction in the number of rules and the simplification of their conditions. The proposed paper largely focuses on reducing the time costs of generating a set of FRBS rules and improving the interpretability/explainability of the results.

The significance of the proposed algorithm for generating fuzzy rules based on the interpretation of the decision tree can be summarized as follows:

• The proposed approach facilitates the rapid construction of an FRBS without requiring a profound understanding of the task, its domain, or the analyzed object.
• The performance of the resulting system will be approximately equivalent to that of the decision tree. The performance depends on the proper selection of the optimal number of fuzzy variables and the types and configurations of membership functions. It is important to note that this article does not discuss the selection of the optimal FRBS parameters.
• In certain situations, it may be necessary to modify the generated fuzzy rules. To address this issue, a clustering algorithm has been proposed which can identify groups of similar rules. This approach can help evaluate the extent of the coverage within the solution space.

In this study, we present an approach to generating fuzzy rules for constructing an FRBS based on the interpretation of the decision tree. To obtain the initial set of rules, we extract rules from the decision tree. The CART algorithm was chosen as the algorithm for training the model to create a binary decision tree. Next, we perform the steps of reducing the number of rules and simplifying the rule conditions. After that, the fuzzification process is performed. For the obtained fuzzy rules, a reduction in the number of rules is also applied. We also presented a set of experiments that allowed us to evaluate the adequacy of the proposed approach. The quality of the decision-tree-based model and the constructed FRBSs is evaluated using the metric $R^2$. The average difference in the $R^2$ metric between the decision tree and the constructed FRBSs is approximately 2%.

Future work plans include the following:

• The development of an approach to generating a set of fuzzy rules based on the interpretation of other machine learning algorithms;
• The development of a method for generating fuzzy sets considering the specifics of the subject area and data to improve the quality of the FRBS;
• Adapting the proposed approach to be compatible with additional fuzzy inference algorithms.