fuzzy-rules-generator/temp_density_tree1.ipynb

In [2]:

import pickle
import pandas as pd
from sklearn import tree

model = pickle.load(open("data/temp_density_tree-gs.model.sav", "rb"))
features = (
    pd.read_csv("data/density_train.csv", sep=";", decimal=",")
    .drop(["T"], axis=1)
    .columns.values.tolist()
)

rules = tree.export_text(model, feature_names=features)
print(rules)

|--- Density <= 1.21
|   |--- TiO2 <= 0.03
|   |   |--- Density <= 1.07
|   |   |   |--- value: [48.33]
|   |   |--- Density >  1.07
|   |   |   |--- Al2O3 <= 0.18
|   |   |   |   |--- Density <= 1.08
|   |   |   |   |   |--- value: [37.50]
|   |   |   |   |--- Density >  1.08
|   |   |   |   |   |--- value: [27.50]
|   |   |   |--- Al2O3 >  0.18
|   |   |   |   |--- value: [50.00]
|   |--- TiO2 >  0.03
|   |   |--- Density <= 1.19
|   |   |   |--- TiO2 <= 0.18
|   |   |   |   |--- value: [50.00]
|   |   |   |--- TiO2 >  0.18
|   |   |   |   |--- value: [65.00]
|   |   |--- Density >  1.19
|   |   |   |--- value: [40.00]
|--- Density >  1.21
|   |--- value: [25.00]

In [3]:

from src.rules import get_rules


rules = get_rules(model, features)
display(len(rules))
rules

8

Out[3]:

[if (Density > 1.208) -> 25.0,
 if (Density <= 1.208) and (TiO2 <= 0.025) and (Density > 1.067) and (Al2O3 <= 0.175) and (Density > 1.079) -> 27.5,
 if (Density <= 1.208) and (TiO2 <= 0.025) and (Density > 1.067) and (Al2O3 <= 0.175) and (Density <= 1.079) -> 37.5,
 if (Density <= 1.208) and (TiO2 <= 0.025) and (Density > 1.067) and (Al2O3 > 0.175) -> 50.0,
 if (Density <= 1.208) and (TiO2 > 0.025) and (Density <= 1.193) and (TiO2 <= 0.175) -> 50.0,
 if (Density <= 1.208) and (TiO2 > 0.025) and (Density <= 1.193) and (TiO2 > 0.175) -> 65.0,
 if (Density <= 1.208) and (TiO2 > 0.025) and (Density > 1.193) -> 40.0,
 if (Density <= 1.208) and (TiO2 <= 0.025) and (Density <= 1.067) -> 48.333]

In [4]:

from src.rules import normalise_rules


rules = normalise_rules(rules)
display(len(rules))
rules

8

Out[4]:

[if (Density > 1.208) -> 25.0,
 if (Density <= 1.208) and (Density > 1.067) and (TiO2 <= 0.025) and (Al2O3 <= 0.175) -> 27.5,
 if (Density <= 1.208) and (Density > 1.067) and (TiO2 <= 0.025) and (Al2O3 <= 0.175) -> 37.5,
 if (Density <= 1.208) and (Density > 1.067) and (TiO2 <= 0.025) and (Al2O3 > 0.175) -> 50.0,
 if (Density <= 1.208) and (TiO2 > 0.025) and (TiO2 <= 0.175) -> 50.0,
 if (Density <= 1.208) and (TiO2 > 0.025) -> 65.0,
 if (Density <= 1.208) and (Density > 1.193) and (TiO2 > 0.025) -> 40.0,
 if (Density <= 1.208) and (TiO2 <= 0.025) -> 48.333]

In [5]:

from src.rules import delete_same_rules


rules = delete_same_rules(rules)
display(len(rules))
rules

7

Out[5]:

[if (Density > 1.208) -> 25.0,
 if (Density <= 1.208) and (Density > 1.067) and (TiO2 <= 0.025) and (Al2O3 <= 0.175) -> 32.5,
 if (Density <= 1.208) and (Density > 1.067) and (TiO2 <= 0.025) and (Al2O3 > 0.175) -> 50.0,
 if (Density <= 1.208) and (TiO2 > 0.025) and (TiO2 <= 0.175) -> 50.0,
 if (Density <= 1.208) and (TiO2 > 0.025) -> 65.0,
 if (Density <= 1.208) and (Density > 1.193) and (TiO2 > 0.025) -> 40.0,
 if (Density <= 1.208) and (TiO2 <= 0.025) -> 48.333]

In [6]:

train = pd.read_csv("data/density_train.csv", sep=";", decimal=",")
test = pd.read_csv("data/density_test.csv", sep=";", decimal=",")

train["Density"] = train["Density"]
test["Density"] = test["Density"]

display(train.head(3))
display(test.head(3))
train.describe().transpose()

	T	Al2O3	TiO2	Density
0	20	0.0	0.0	1.06250
1	25	0.0	0.0	1.05979
2	35	0.0	0.0	1.05404

	T	Al2O3	TiO2	Density
0	30	0.00	0.0	1.05696
1	55	0.00	0.0	1.04158
2	25	0.05	0.0	1.08438

Out[6]:

	count	mean	std	min	25%	50%	75%	max
T	38.0	45.526316	16.513282	20.00000	31.25000	45.000000	60.000000	70.0000
Al2O3	38.0	0.078947	0.126080	0.00000	0.00000	0.000000	0.050000	0.3000
TiO2	38.0	0.057895	0.108133	0.00000	0.00000	0.000000	0.050000	0.3000
Density	38.0	1.108180	0.060772	1.03182	1.05763	1.082755	1.169058	1.2186

In [7]:

from src.rules import simplify_rules

rules = simplify_rules(train, rules)
display(len(rules))
rules

7

Out[7]:

[if (Density = 1.219) -> 25.0,
 if (Density = 1.138) and (TiO2 = 0.0) and (Al2O3 = 0.0) -> 32.5,
 if (Density = 1.138) and (TiO2 = 0.0) and (Al2O3 = 0.3) -> 50.0,
 if (Density = 1.032) and (TiO2 = 0.1) -> 50.0,
 if (Density = 1.032) and (TiO2 = 0.3) -> 65.0,
 if (Density = 1.2) and (TiO2 = 0.3) -> 40.0,
 if (Density = 1.032) and (TiO2 = 0.0) -> 48.333]

In [19]:

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

al = ctrl.Antecedent(np.arange(0, 0.3, 0.1), "al")
ti = ctrl.Antecedent(np.arange(0, 0.3, 0.1), "ti")
density = ctrl.Antecedent(np.arange(1.03, 1.22, 0.001), "density")
# temp = ctrl.Consequent(train["T"].sort_values().unique(), "temp")
temp = ctrl.Consequent(np.arange(20, 70, 1), "temp")

al.automf(3, variable_type="quant")
al.view()
ti.automf(3, variable_type="quant")
ti.view()
density.automf(3, variable_type="quant")
density.view()
temp.automf(7, variable_type="quant")
temp.view()

/Users/user/Projects/python/fuzzy-rules-generator/.venv/lib/python3.12/site-packages/skfuzzy/control/fuzzyvariable.py:125: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown
  fig.show()

In [20]:

from src.rules import get_fuzzy_rules

fuzzy_variables = {"Al2O3": al, "TiO2": ti, "Density": density, "consequent": temp}
fuzzy_rules = get_fuzzy_rules(rules, fuzzy_variables)
fuzzy_rules.remove(fuzzy_rules[5])

fuzzy_cntrl = ctrl.ControlSystem(fuzzy_rules)

sim = ctrl.ControlSystemSimulation(fuzzy_cntrl, lenient=False)

display(len(fuzzy_rules))
fuzzy_rules

6

Out[20]:

[IF density[high] THEN temp[lower]
 	AND aggregation function : fmin
 	OR aggregation function  : fmax,
 IF (density[average] AND ti[low]) AND al[low] THEN temp[low]
 	AND aggregation function : fmin
 	OR aggregation function  : fmax,
 IF (density[average] AND ti[low]) AND al[high] THEN temp[high]
 	AND aggregation function : fmin
 	OR aggregation function  : fmax,
 IF density[low] AND ti[average] THEN temp[high]
 	AND aggregation function : fmin
 	OR aggregation function  : fmax,
 IF density[low] AND ti[high] THEN temp[highest]
 	AND aggregation function : fmin
 	OR aggregation function  : fmax,
 IF density[low] AND ti[low] THEN temp[average]
 	AND aggregation function : fmin
 	OR aggregation function  : fmax]

In [21]:

sim.input["al"] = 0.0
sim.input["ti"] = 0.0
sim.input["density"] = 1.056
sim.compute()
sim.print_state()
display(sim.output["temp"])
temp.view(sim=sim)

=============
 Antecedents 
=============
Antecedent: density                 = 1.056
  - low                             : 0.7248677248676944
  - average                         : 0.27513227513230565
  - high                            : 0.0
Antecedent: ti                      = 0.0
  - low                             : 1.0
  - average                         : 0.0
  - high                            : 0.0
Antecedent: al                      = 0.0
  - low                             : 1.0
  - average                         : 0.0
  - high                            : 0.0

=======
 Rules 
=======
RULE #0:
  IF density[high] THEN temp[lower]
	AND aggregation function : fmin
	OR aggregation function  : fmax

  Aggregation (IF-clause):
  - density[high]                                          : 0.0
                                             density[high] = 0.0
  Activation (THEN-clause):
                                               temp[lower] : 0.0

RULE #1:
  IF (density[average] AND ti[low]) AND al[low] THEN temp[low]
	AND aggregation function : fmin
	OR aggregation function  : fmax

  Aggregation (IF-clause):
  - density[average]                                       : 0.27513227513230565
  - ti[low]                                                : 1.0
  - al[low]                                                : 1.0
                (density[average] AND ti[low]) AND al[low] = 0.27513227513230565
  Activation (THEN-clause):
                                                 temp[low] : 0.27513227513230565

RULE #2:
  IF (density[average] AND ti[low]) AND al[high] THEN temp[high]
	AND aggregation function : fmin
	OR aggregation function  : fmax

  Aggregation (IF-clause):
  - density[average]                                       : 0.27513227513230565
  - ti[low]                                                : 1.0
  - al[high]                                               : 0.0
               (density[average] AND ti[low]) AND al[high] = 0.0
  Activation (THEN-clause):
                                                temp[high] : 0.0

RULE #3:
  IF density[low] AND ti[average] THEN temp[high]
	AND aggregation function : fmin
	OR aggregation function  : fmax

  Aggregation (IF-clause):
  - density[low]                                           : 0.7248677248676944
  - ti[average]                                            : 0.0
                              density[low] AND ti[average] = 0.0
  Activation (THEN-clause):
                                                temp[high] : 0.0

RULE #4:
  IF density[low] AND ti[high] THEN temp[highest]
	AND aggregation function : fmin
	OR aggregation function  : fmax

  Aggregation (IF-clause):
  - density[low]                                           : 0.7248677248676944
  - ti[high]                                               : 0.0
                                 density[low] AND ti[high] = 0.0
  Activation (THEN-clause):
                                             temp[highest] : 0.0

RULE #5:
  IF density[low] AND ti[low] THEN temp[average]
	AND aggregation function : fmin
	OR aggregation function  : fmax

  Aggregation (IF-clause):
  - density[low]                                           : 0.7248677248676944
  - ti[low]                                                : 1.0
                                  density[low] AND ti[low] = 0.7248677248676944
  Activation (THEN-clause):
                                             temp[average] : 0.7248677248676944


==============================
 Intermediaries and Conquests 
==============================
Consequent: temp                     = 41.945501934095006
  lowest:
    Accumulate using accumulation_max : None
  lower:
    Accumulate using accumulation_max : 0.0
  low:
    Accumulate using accumulation_max : 0.27513227513230565
  average:
    Accumulate using accumulation_max : 0.7248677248676944
  high:
    Accumulate using accumulation_max : 0.0
  higher:
    Accumulate using accumulation_max : None
  highest:
    Accumulate using accumulation_max : 0.0

np.float64(41.945501934095006)

In [22]:

from sklearn import metrics
import math


def fuzzy_pred(row):
    sim.input["al"] = row["Al2O3"]
    sim.input["ti"] = row["TiO2"]
    sim.input["density"] = row["Density"]
    sim.compute()
    return sim.output["temp"]


def rmse(row):
    return math.sqrt(metrics.mean_squared_error([row["Real"]], [row["Inferred"]]))


result_train = train.copy()
result_train["Real"] = result_train["T"]
result_train["Inferred"] = result_train.apply(fuzzy_pred, axis=1)
result_train["RMSE"] = result_train.apply(rmse, axis=1)
result_train = result_train.round({"RMSE": 3})
result_train.head(15)

Out[22]:

	T	Al2O3	TiO2	Density	Real	Inferred	RMSE
0	20	0.00	0.0	1.06250	20	41.459120	21.459
1	25	0.00	0.0	1.05979	25	41.659673	16.660
2	35	0.00	0.0	1.05404	35	42.099779	7.100
3	40	0.00	0.0	1.05103	40	42.347242	2.347
4	45	0.00	0.0	1.04794	45	42.610185	2.390
5	50	0.00	0.0	1.04477	50	42.889015	7.111
6	60	0.00	0.0	1.03826	60	43.534924	16.465
7	65	0.00	0.0	1.03484	65	43.903559	21.096
8	70	0.00	0.0	1.03182	70	44.262804	25.737
9	20	0.05	0.0	1.08755	20	39.993857	19.994
10	45	0.05	0.0	1.07105	45	40.851253	4.149
11	50	0.05	0.0	1.06760	50	41.091876	8.908
12	55	0.05	0.0	1.06409	55	41.342701	13.657
13	65	0.05	0.0	1.05691	65	41.875477	23.125
14	70	0.05	0.0	1.05291	70	42.191078	27.809

In [23]:

result_test = test.copy()
result_test["Real"] = result_test["T"]
result_test["Inferred"] = result_test.apply(fuzzy_pred, axis=1)
result_test["RMSE"] = result_test.apply(rmse, axis=1)
result_test = result_test.round({"RMSE": 3})
result_test

Out[23]:

	T	Al2O3	TiO2	Density	Real	Inferred	RMSE
0	30	0.00	0.00	1.05696	30	41.871657	11.872
1	55	0.00	0.00	1.04158	55	43.191501	11.808
2	25	0.05	0.00	1.08438	25	40.142006	15.142
3	30	0.05	0.00	1.08112	30	40.279597	10.280
4	35	0.05	0.00	1.07781	35	40.403354	5.403
5	40	0.05	0.00	1.07446	40	40.615252	0.615
6	60	0.05	0.00	1.06053	60	41.605489	18.395
7	35	0.30	0.00	1.17459	35	39.941390	4.941
8	65	0.30	0.00	1.14812	65	44.873522	20.126
9	45	0.00	0.05	1.07424	45	44.652831	0.347
10	50	0.00	0.05	1.07075	50	44.842298	5.158
11	55	0.00	0.05	1.06721	55	45.048945	9.951
12	20	0.00	0.30	1.22417	20	28.180000	8.180
13	30	0.00	0.30	1.21310	30	28.180272	1.820
14	40	0.00	0.30	1.20265	40	28.180858	11.819
15	60	0.00	0.30	1.18265	60	28.182820	31.817
16	70	0.00	0.30	1.17261	70	28.184796	41.815

In [24]:

import matplotlib.pyplot as plt

result_test.hist(bins=30, figsize=(10, 10))
plt.show()

In [25]:

rmetrics = {}
rmetrics["RMSE_train"] = math.sqrt(
    metrics.mean_squared_error(result_train["Real"], result_train["Inferred"])
)
rmetrics["RMSE_test"] = math.sqrt(
    metrics.mean_squared_error(result_test["Real"], result_test["Inferred"])
)
rmetrics["RMAE_test"] = math.sqrt(
    metrics.mean_absolute_error(result_test["Real"], result_test["Inferred"])
)
rmetrics["R2_test"] = metrics.r2_score(result_test["Real"], result_test["Inferred"])

rmetrics

Out[25]:

{'RMSE_train': 17.1096971907754,
 'RMSE_test': 16.286513096011436,
 'RMAE_test': 3.5104040610801057,
 'R2_test': -0.2434289870376889}