# Auto-membership function population is possible with .automf(3, 5, or 7)
work_experience.automf(3)
technical_Knowledge.automf(3)
# Custom membership functions can be built interactively with a familiar, Pythonic API
experience['low'] = fuzz.trimf(experience.universe, [0, 0, 25])
experience['medium'] = fuzz.trimf(experience.universe, [0, 25, 50])
experience['high'] = fuzz.trimf(experience.universe, [25, 50, 50])
#define rules
rule1 = ctrl.Rule(work_experience['poor'] | technical_Knowledge['poor'],
experience['low'])
rule2 = ctrl.Rule(technical_Knowledge['average'], experience['medium'])
rule3 = ctrl.Rule(technical_Knowledge['good'] | work_experience['good'],
experience['high'])
#create the control system
experience_ctrl = ctrl.ControlSystem([rule1, rule2, rule3])
experiencing = ctrl.ControlSystemSimulation(experience_ctrl)
# Pass inputs to the ControlSystem using Antecedent labels with Pythonic API
# Note: if you like passing many inputs all at once, use .inputs(dict_of_data)
we_array = []
tk_array = []
with open('FIS_Data.csv') as csvDataFile:
csvReader = csv.reader(csvDataFile)
for row in csvReader:
we_array.append(row[2])
tk_array.append(row[3])
c1array = []
for x in range(0, len(we_array)):
experiencing.input['work_experience'] = float(we_array[x])
experiencing.input['technical_Knowledge'] = float(tk_array[x])
experiencing.compute() #Crunch the numbers
def acc_intention(acc_pedal, acc_drt):
# New Antecedent/Consequent objects hold universe variables and membership
acc = ctrl.Antecedent(np.linspace(0, 1, 21), 'acceleration')
acc_derivative = ctrl.Antecedent(np.linspace(-1, 1, 81),
'derivative of acceleration')
driver_intention = ctrl.Consequent(np.linspace(0, 1, 21),
'driver intention')
# Membership functions
acc['S'] = fuzz.trapmf(acc.universe, [0, 0, 0.15, 0.25])
acc['RS'] = fuzz.trimf(acc.universe, [0.1, 0.25, 0.4])
acc['M'] = fuzz.trimf(acc.universe, [0.3, 0.45, 0.6])
acc['RB'] = fuzz.trimf(acc.universe, [0.5, 0.65, 0.8])
acc['B'] = fuzz.trapmf(acc.universe, [0.7, 0.85, 1, 1])
acc_derivative['NB'] = fuzz.trapmf(acc_derivative.universe,
[-1, -1, -0.7, -0.4])
acc_derivative['NS'] = fuzz.trimf(acc_derivative.universe,
[-0.6, -0.225, 0.15])
acc_derivative['S'] = fuzz.trimf(acc_derivative.universe,
[-0.15, 0.1, 0.35])
acc_derivative['M'] = fuzz.trimf(acc_derivative.universe, [0.3, 0.45, 0.6])
acc_derivative['B'] = fuzz.trapmf(acc_derivative.universe,
[0.5, 0.7, 1, 1])
driver_intention['NL'] = fuzz.trapmf(driver_intention.universe,
[0, 0, 0.1, 0.15])
driver_intention['NS'] = fuzz.trimf(driver_intention.universe,
[0.1, 0.25, 0.4])
driver_intention['ZE'] = fuzz.trimf(driver_intention.universe,
[0.3, 0.45, 0.6])
driver_intention['PS'] = fuzz.trimf(driver_intention.universe,
[0.5, 0.65, 0.8])
driver_intention['PL'] = fuzz.trapmf(driver_intention.universe,
[0.7, 0.8, 1, 1])
acc.view()
acc_derivative.view()
driver_intention.view()
# Define rule base
rule1 = ctrl.Rule(acc['S'] & acc_derivative['NB'], driver_intention['NL'])
rule2 = ctrl.Rule(acc['S'] & acc_derivative['NS'], driver_intention['NL'])
rule3 = ctrl.Rule(acc['S'] & acc_derivative['S'], driver_intention['NS'])
rule4 = ctrl.Rule(acc['S'] & acc_derivative['M'], driver_intention['NS'])
rule5 = ctrl.Rule(acc['S'] & acc_derivative['B'], driver_intention['ZE'])
rule6 = ctrl.Rule(acc['RS'] & acc_derivative['NB'], driver_intention['NL'])
rule7 = ctrl.Rule(acc['RS'] & acc_derivative['NS'], driver_intention['NS'])
rule8 = ctrl.Rule(acc['RS'] & acc_derivative['S'], driver_intention['NS'])
rule9 = ctrl.Rule(acc['RS'] & acc_derivative['M'], driver_intention['ZE'])
rule10 = ctrl.Rule(acc['RS'] & acc_derivative['B'], driver_intention['PS'])
rule11 = ctrl.Rule(acc['M'] & acc_derivative['NB'], driver_intention['NS'])
rule12 = ctrl.Rule(acc['M'] & acc_derivative['NS'], driver_intention['ZE'])
rule13 = ctrl.Rule(acc['M'] & acc_derivative['S'], driver_intention['ZE'])
rule14 = ctrl.Rule(acc['M'] & acc_derivative['M'], driver_intention['PS'])
rule15 = ctrl.Rule(acc['M'] & acc_derivative['B'], driver_intention['PL'])
rule16 = ctrl.Rule(acc['RB'] & acc_derivative['NB'],
driver_intention['NS'])
rule17 = ctrl.Rule(acc['RB'] & acc_derivative['NS'],
driver_intention['ZE'])
rule18 = ctrl.Rule(acc['RB'] & acc_derivative['S'], driver_intention['PS'])
rule19 = ctrl.Rule(acc['RB'] & acc_derivative['M'], driver_intention['PS'])
rule20 = ctrl.Rule(acc['RB'] & acc_derivative['B'], driver_intention['PL'])
rule21 = ctrl.Rule(acc['B'] & acc_derivative['NB'], driver_intention['ZE'])
rule22 = ctrl.Rule(acc['B'] & acc_derivative['NS'], driver_intention['ZE'])
rule23 = ctrl.Rule(acc['B'] & acc_derivative['S'], driver_intention['PS'])
rule24 = ctrl.Rule(acc['B'] & acc_derivative['M'], driver_intention['PL'])
rule25 = ctrl.Rule(acc['B'] & acc_derivative['B'], driver_intention['PL'])
# rule1.view()
# Create control systems
driver_intention_ctrl = ctrl.ControlSystem([
rule1, rule2, rule3, rule4, rule5, rule6, rule7, rule8, rule9, rule10,
rule11, rule12, rule12, rule13, rule14, rule15, rule16, rule16, rule17,
rule18, rule19, rule20, rule21, rule22, rule23, rule24, rule25
])
driver_intention_fc = ctrl.ControlSystemSimulation(driver_intention_ctrl)
driver_intention_fc.input['acceleration'] = acc_pedal
driver_intention_fc.input['derivative of acceleration'] = acc_drt
driver_intention_fc.compute()
def __init__(self,
R=None,
Q=None,
P=None,
x=None,
q=None,
window_width=12,
a=0.95):
if R is None:
R = np.diag([1, 1, 1, 1 * 5, 1 * 5, 1 * 5]) * 1e-1
if Q is None:
Q = np.diag(
[0.06**2, 0.06**2, 0.06**2, 0, 0, 0, 0.1, 0.1, 0.1, 0, 0, 0])
if P is None:
P = np.diag([
0.1, 0.1, 0.1, 0.05, 0.05, 0.05, 0, 0, 0, 0.01, 0.01, 0.01, 0,
0, 0
])
if x is None:
x = np.array(
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
np.float) # position, velocity, acceleration bias, omega bias
if q is None:
q = quaternion.from_rotation_vector(
np.array([0, 0, 0.701], np.float))
q = quaternion.as_float_array(q)
'''
Filter mode must be set to:
0 - for Sage-Husa Fuzzy Adaptive Filter
1 - for Sage-Husa Adaptive Filter
2 - for EKF
3 - for Inertial Navigation
'''
self.mode = 0
self.on = True
self.lamb = np.block([[np.zeros((3, 12), np.float)],
[np.identity(12, np.float)]])
self.H = np.block(
[[np.identity(6, np.float),
np.zeros((6, 9), np.float)]])
self.threshold = 4.5
a_v = np.ones(window_width, np.float) * a
j = np.arange(0, window_width)
s = np.power(a_v, j) * (1 - a_v) / (1 - np.power(a_v, window_width))
self.sigma = np.diag(s)
self.time = 0
self.uwbTime = 0
self.nAnchors = 4
self.anchorPos = np.zeros((2, self.nAnchors), np.float)
self.range = np.ones(self.nAnchors, np.float) * 99
self.uwbCeck = np.zeros(
self.nAnchors) # check if all anchors' signals arrived
self.uwbInit = 0 # flag for uwb velocity initialization
self.pred = 0 # flag which states if prediction or correction has been performed last
beta = 0
self.G = 1 - np.square(beta)
self.H_uwb = np.square(1 - beta)
self.R = R
self.Q = Q
self.P = P
self.P_ = P
self.x = x[np.newaxis].T
self.x_ = x[np.newaxis].T
self.posOld = x[:3]
self.velOld = x[3:6]
self.q = q
self.q_ = q
self.dx = np.array(
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], np.float
)[np.
newaxis].T # position, velocity, orientation, acceleration bias, omega bias
self.dx_ = np.array(
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], np.float
)[np.
newaxis].T # position, velocity, orientation, acceleration bias, omega bias
self.innovation = np.random.normal(0.0, 0.1, (6, window_width))
self.error = (np.random.rand(15, window_width) - 1) * 0.1
# self.innovation_ = np.zeros((6,window_width), np.float)
self.k = 0 # Iteration counter
self.lambda_ = 1.0119 # Sage Huza ICW coefficent
self.b = 0.9976 # Sage Huza ICW coefficent
self.alpha = 0.48 # Sage Huza ICW coefficent
H = self.H
self.K = H.T.dot(np.linalg.inv(H.dot(H.T))) # Kalman gain
# Fuzzy inference
input = ctrl.Antecedent(np.arange(0, 0.9, 0.1), 'r')
output = ctrl.Consequent(np.arange(0.8, 2.1, 0.1), 's')
# Define membership functions
input['less'] = fuzz.trimf(input.universe, [0, 0, 0.3])
input['equal'] = fuzz.trimf(input.universe, [0.1, 0.4, 0.7])
input['more'] = fuzz.trimf(input.universe, [0.5, 0.8, 0.8])
output['less'] = fuzz.trimf(output.universe, [0.8, 0.8, 1.2])
output['equal'] = fuzz.trimf(output.universe, [1, 1.4, 1.8])
output['more'] = fuzz.trimf(output.universe, [1.6, 2.0, 2.0])
# Fuzzy rules
rule1 = ctrl.Rule(input['equal'], output['equal'])
rule2 = ctrl.Rule(input['more'], output['more'])
rule3 = ctrl.Rule(input['less'], output['less'])
fuzzy_control = ctrl.ControlSystem([rule1, rule2, rule3])
self.fuzzy = ctrl.ControlSystemSimulation(fuzzy_control)
def compute_fuzzy(attend, intr_mark, extn_mark):
intrn_marks = ctrl.Antecedent(np.arange(0, 105, 5), INTERNAL_MARKS)
attendance = ctrl.Antecedent(np.arange(0, 105, 5), ATTENDANCE)
extrn_marks = ctrl.Antecedent(np.arange(0, 105, 5), EXTERNAL_MARKS)
performance = ctrl.Consequent(np.arange(0, 105, 5), PERFORMANCE)
intrn_marks[POOR] = fuzz.trapmf(intrn_marks.universe, low_parameter)
intrn_marks[AVERAGE] = fuzz.trapmf(intrn_marks.universe, average_parameter)
intrn_marks[GOOD] = fuzz.trapmf(intrn_marks.universe, good_parameter)
intrn_marks[V_GOOD] = fuzz.trapmf(intrn_marks.universe, v_good_parameter)
intrn_marks[EXCELLENT] = fuzz.trapmf(intrn_marks.universe,
excellent_parameter)
attendance[POOR] = fuzz.trapmf(attendance.universe, [0, 0, 45, 55])
attendance[AVERAGE] = fuzz.trapmf(attendance.universe, [35, 45, 55, 65])
attendance[GOOD] = fuzz.trapmf(attendance.universe, [45, 55, 65, 75])
attendance[V_GOOD] = fuzz.trapmf(attendance.universe, [55, 65, 75, 85])
attendance[EXCELLENT] = fuzz.trapmf(attendance.universe,
[65, 75, 100, 100])
extrn_marks[POOR] = fuzz.trapmf(extrn_marks.universe, low_parameter)
extrn_marks[AVERAGE] = fuzz.trapmf(extrn_marks.universe, average_parameter)
extrn_marks[GOOD] = fuzz.trapmf(extrn_marks.universe, good_parameter)
extrn_marks[V_GOOD] = fuzz.trapmf(extrn_marks.universe, v_good_parameter)
extrn_marks[EXCELLENT] = fuzz.trapmf(extrn_marks.universe,
excellent_parameter)
performance[POOR] = fuzz.trapmf(performance.universe, low_parameter)
performance[AVERAGE] = fuzz.trapmf(performance.universe, average_parameter)
performance[GOOD] = fuzz.trapmf(performance.universe, good_parameter)
performance[V_GOOD] = fuzz.trapmf(performance.universe, v_good_parameter)
performance[EXCELLENT] = fuzz.trapmf(performance.universe,
excellent_parameter)
rule1 = ctrl.Rule(attendance[POOR] & extrn_marks[POOR] & intrn_marks[POOR],
performance[POOR])
rule2 = ctrl.Rule(
attendance[POOR] & extrn_marks[AVERAGE] & intrn_marks[POOR],
performance[POOR])
rule3 = ctrl.Rule(attendance[POOR] & extrn_marks[GOOD] & intrn_marks[POOR],
performance[AVERAGE])
rule4 = ctrl.Rule(
attendance[POOR] & extrn_marks[V_GOOD] & intrn_marks[POOR],
performance[AVERAGE])
rule5 = ctrl.Rule(
attendance[POOR] & extrn_marks[GOOD] & intrn_marks[V_GOOD],
performance[GOOD])
rule6 = ctrl.Rule(
attendance[POOR] & extrn_marks[POOR] & intrn_marks[AVERAGE],
performance[POOR])
rule7 = ctrl.Rule(
attendance[POOR] & extrn_marks[AVERAGE] & intrn_marks[AVERAGE],
performance[AVERAGE])
rule8 = ctrl.Rule(
attendance[POOR] & extrn_marks[GOOD] & intrn_marks[AVERAGE],
performance[AVERAGE])
rule9 = ctrl.Rule(
(attendance[POOR] & extrn_marks[GOOD] & intrn_marks[GOOD]),
performance[GOOD])
rule10 = ctrl.Rule(
attendance[POOR] & extrn_marks[EXCELLENT] & intrn_marks[GOOD],
performance[V_GOOD])
rule11 = ctrl.Rule(
attendance[AVERAGE] & extrn_marks[AVERAGE] & intrn_marks[GOOD],
performance[AVERAGE])
rule12 = ctrl.Rule(
attendance[AVERAGE] & extrn_marks[GOOD] & intrn_marks[GOOD],
performance[GOOD])
rule13 = ctrl.Rule(
attendance[AVERAGE] & extrn_marks[V_GOOD] & intrn_marks[GOOD],
performance[GOOD])
rule14 = ctrl.Rule(
attendance[AVERAGE] & extrn_marks[V_GOOD] & intrn_marks[V_GOOD],
performance[V_GOOD])
rule15 = ctrl.Rule(
attendance[AVERAGE] & extrn_marks[AVERAGE] & intrn_marks[EXCELLENT],
performance[GOOD])
rule16 = ctrl.Rule(
attendance[AVERAGE] & extrn_marks[AVERAGE] & intrn_marks[AVERAGE],
performance[AVERAGE])
rule17 = ctrl.Rule(
attendance[AVERAGE] & extrn_marks[POOR] & intrn_marks[POOR],
performance[POOR])
rule18 = ctrl.Rule(
attendance[AVERAGE] & extrn_marks[POOR] & intrn_marks[GOOD],
performance[AVERAGE])
rule19 = ctrl.Rule(
attendance[GOOD] & extrn_marks[AVERAGE] & intrn_marks[AVERAGE],
performance[AVERAGE])
rule20 = ctrl.Rule(
attendance[GOOD] & extrn_marks[EXCELLENT] & intrn_marks[EXCELLENT],
performance[V_GOOD])
rule21 = ctrl.Rule(
attendance[GOOD] & extrn_marks[GOOD] & intrn_marks[AVERAGE],
performance[GOOD])
rule22 = ctrl.Rule(
attendance[GOOD] & extrn_marks[POOR] & intrn_marks[POOR],
performance[POOR])
rule23 = ctrl.Rule(
attendance[V_GOOD] & extrn_marks[EXCELLENT] & intrn_marks[V_GOOD],
performance[V_GOOD])
rule24 = ctrl.Rule(
attendance[V_GOOD] & extrn_marks[V_GOOD] & intrn_marks[V_GOOD],
performance[V_GOOD])
rule25 = ctrl.Rule(
attendance[V_GOOD] & extrn_marks[POOR] & intrn_marks[POOR],
performance[POOR])
rule26 = ctrl.Rule(
attendance[V_GOOD] & extrn_marks[GOOD] & intrn_marks[V_GOOD],
performance[V_GOOD])
rule27 = ctrl.Rule(
attendance[V_GOOD] & extrn_marks[EXCELLENT] & intrn_marks[EXCELLENT],
performance[EXCELLENT])
rule28 = ctrl.Rule(
attendance[EXCELLENT] & extrn_marks[EXCELLENT] & intrn_marks[V_GOOD],
performance[V_GOOD])
rule29 = ctrl.Rule(
attendance[EXCELLENT] & extrn_marks[AVERAGE] & intrn_marks[AVERAGE],
performance[V_GOOD])
rule30 = ctrl.Rule(
attendance[EXCELLENT] & extrn_marks[AVERAGE] & intrn_marks[V_GOOD],
performance[GOOD])
rule31 = ctrl.Rule(
attendance[EXCELLENT] & extrn_marks[AVERAGE] & intrn_marks[GOOD],
performance[GOOD])
rule32 = ctrl.Rule(
attendance[EXCELLENT] & extrn_marks[POOR] & intrn_marks[POOR],
performance[POOR])
rule33 = ctrl.Rule(
attendance[EXCELLENT] & extrn_marks[AVERAGE] & intrn_marks[POOR],
performance[AVERAGE])
rule34 = ctrl.Rule(
attendance[EXCELLENT] & extrn_marks[POOR] & intrn_marks[AVERAGE],
performance[POOR])
rule35 = ctrl.Rule(
attendance[EXCELLENT] & extrn_marks[GOOD] & intrn_marks[POOR],
performance[GOOD])
rule36 = ctrl.Rule(
attendance[EXCELLENT] & extrn_marks[POOR] & intrn_marks[GOOD],
performance[AVERAGE])
rule37 = ctrl.Rule(
attendance[EXCELLENT] & extrn_marks[V_GOOD] & intrn_marks[POOR],
performance[V_GOOD])
rule38 = ctrl.Rule(
attendance[EXCELLENT] & extrn_marks[POOR] & intrn_marks[V_GOOD],
performance[AVERAGE])
rule39 = ctrl.Rule(
attendance[EXCELLENT] & extrn_marks[POOR] & intrn_marks[EXCELLENT],
performance[GOOD])
rule40 = ctrl.Rule(
attendance[EXCELLENT] & extrn_marks[AVERAGE] & intrn_marks[EXCELLENT],
performance[V_GOOD])
rule41 = ctrl.Rule(
attendance[EXCELLENT] & extrn_marks[GOOD] & intrn_marks[EXCELLENT],
performance[V_GOOD])
rule42 = ctrl.Rule(
attendance[EXCELLENT] & extrn_marks[V_GOOD] & intrn_marks[EXCELLENT],
performance[V_GOOD])
rule43 = ctrl.Rule(
attendance[EXCELLENT] & extrn_marks[EXCELLENT]
& intrn_marks[EXCELLENT], performance[EXCELLENT])
#intrn_marks.view()
#attendance.view()
#extrn_marks.view()
#performance.view()
rule_list = [
rule1, rule2, rule3, rule4, rule5, rule6, rule7, rule8, rule9, rule10,
rule11, rule12, rule13, rule14, rule15, rule16, rule17, rule18, rule19,
rule20, rule21, rule22, rule23, rule24, rule25, rule26, rule27, rule28,
rule29, rule30, rule31, rule32, rule33, rule34, rule35, rule36, rule37,
rule38, rule39, rule40, rule41, rule42, rule43
]
performance_ctrl = ctrl.ControlSystem(rule_list)
perf_analysis = ctrl.ControlSystemSimulation(performance_ctrl)
perf_analysis.input[ATTENDANCE] = attend
perf_analysis.input[EXTERNAL_MARKS] = extn_mark
perf_analysis.input[INTERNAL_MARKS] = intr_mark
perf_analysis.compute()
return (str(perf_analysis.output[PERFORMANCE]))
def build_fuzzy_system(self):
# Sparse universe makes calculations faster, without sacrifice accuracy.
# Only the critical points are included here; making it higher resolution is
# unnecessary.
"""============================================================="""
low_force = self.low_input
high_force = self.high_input
num_input = self.num_input
fx_universe = np.linspace(low_force[0], high_force[0], num_input)
fy_universe = np.linspace(low_force[1], high_force[1], num_input)
fz_universe = np.linspace(low_force[2], high_force[2], num_input)
mx_universe = np.linspace(low_force[3], low_force[3], num_input)
my_universe = np.linspace(low_force[4], low_force[4], num_input)
mz_universe = np.linspace(low_force[5], low_force[5], num_input)
"""Create the three fuzzy variables - two inputs, one output"""
fx = ctrl.Antecedent(fx_universe, 'fx')
fy = ctrl.Antecedent(fy_universe, 'fy')
fz = ctrl.Antecedent(fz_universe, 'fz')
mx = ctrl.Antecedent(mx_universe, 'mx')
my = ctrl.Antecedent(my_universe, 'my')
mz = ctrl.Antecedent(mz_universe, 'mz')
input_names = ['nb', 'ns', 'ze', 'ps', 'pb']
fx.automf(names=input_names)
fy.automf(names=input_names)
fz.automf(names=input_names)
mx.automf(names=input_names)
my.automf(names=input_names)
mz.automf(names=input_names)
"""============================================================="""
"""Create the outputs"""
kpx_universe = np.linspace(self.low_output[0], self.high_output[0], self.num_output)
kpy_universe = np.linspace(self.low_output[1], self.high_output[1], self.num_output)
kpz_universe = np.linspace(self.low_output[2], self.high_output[2], self.num_output)
krx_universe = np.linspace(self.low_output[3], self.high_output[3], 3)
kry_universe = np.linspace(self.low_output[4], self.high_output[4], 3)
krz_universe = np.linspace(self.low_output[5], self.high_output[5], 3)
kpx = ctrl.Consequent(kpx_universe, 'kpx')
kpy = ctrl.Consequent(kpy_universe, 'kpy')
kpz = ctrl.Consequent(kpz_universe, 'kpz')
krx = ctrl.Consequent(krx_universe, 'krx')
kry = ctrl.Consequent(kry_universe, 'kry')
krz = ctrl.Consequent(krz_universe, 'krz')
output_names_3 = ['nb', 'ze', 'pb']
# Here we use the convenience `automf` to populate the fuzzy variables with
# terms. The optional kwarg `names=` lets us specify the names of our Terms.
kpx.automf(names=output_names_3)
kpy.automf(names=output_names_3)
kpz.automf(names=output_names_3)
krx.automf(names=output_names_3)
kry.automf(names=output_names_3)
krz.automf(names=output_names_3)
# define the rules for the desired force fx and my
# ===============================================================
rule_kpx_0 = ctrl.Rule(antecedent=((fx['nb'] & my['ze']) |
(fx['nb'] & my['ns']) |
(fx['pb'] & my['ze']) |
(fx['pb'] & my['ps'])),
consequent=kpx['pb'], label='rule kpx pb')
rule_kpx_1 = ctrl.Rule(antecedent=((fx['ns'] & my['ze']) |
(fx['ns'] & my['ns']) |
(fx['ns'] & my['nb']) |
(fx['nb'] & my['nb']) |
(fx['pb'] & my['pb']) |
(fx['ps'] & my['ps']) |
(fx['ps'] & my['pb']) |
(fx['ps'] & my['ze'])),
consequent=kpx['ze'], label='rule kpx ze')
rule_kpx_2 = ctrl.Rule(antecedent=((fx['ze'] & my['ze']) |
(fx['ze'] & my['ps']) |
(fx['ze'] & my['ns']) |
(fx['ze'] & my['pb']) |
(fx['ze'] & my['nb']) |
(fx['nb'] & my['ps']) |
(fx['nb'] & my['pb']) |
(fx['pb'] & my['ns']) |
(fx['pb'] & my['nb']) |
(fx['ns'] & my['ps']) |
(fx['ns'] & my['pb']) |
(fx['ps'] & my['nb']) |
(fx['ps'] & my['ns'])),
consequent=kpx['nb'], label='rule kpx nb')
system_kpx = ctrl.ControlSystem(rules=[rule_kpx_2, rule_kpx_1, rule_kpx_0])
sim_kpx = ctrl.ControlSystemSimulation(system_kpx, flush_after_run=self.num_mesh * self.num_mesh + 1)
# define the rules for the desired force fy and mz
# ===============================================================
rule_kpy_0 = ctrl.Rule(antecedent=((fy['nb'] & mx['ns']) |
(fy['nb'] & mx['ze']) |
(fy['pb'] & mx['ze']) |
(fy['pb'] & mx['ps'])),
consequent=kpy['pb'], label='rule_kpy_pb')
rule_kpy_1 = ctrl.Rule(antecedent=((fy['ns'] & mx['ze']) |
(fy['ns'] & mx['ns']) |
(fy['ns'] & mx['nb']) |
(fy['ps'] & mx['ps']) |
(fy['ps'] & mx['pb']) |
(fy['ps'] & mx['ze']) |
(fy['nb'] & mx['nb']) |
(fy['pb'] & mx['pb'])),
consequent=kpy['ze'], label='rule_kpy_ze')
rule_kpy_2 = ctrl.Rule(antecedent=((fy['ze']) |
(fy['nb'] & mx['ps']) |
(fy['nb'] & mx['pb']) |
(fy['pb'] & mx['ns']) |
(fy['pb'] & mx['nb']) |
(fy['ns'] & mx['ps']) |
(fy['ns'] & mx['pb']) |
(fy['ps'] & mx['nb']) |
(fy['ps'] & mx['ns'])),
consequent=kpy['nb'], label='rule_kpy_nb')
system_kpy = ctrl.ControlSystem(rules=[rule_kpy_0, rule_kpy_1, rule_kpy_2])
sim_kpy = ctrl.ControlSystemSimulation(system_kpy, flush_after_run=self.num_mesh * self.num_mesh + 1)
# ===============================================================
rule_kpz_0 = ctrl.Rule(antecedent=((fx['ze'] & fy['ze']) |
(fx['ze'] & fy['ns']) |
(fx['ns'] & fy['ze']) |
(fx['ze'] & fy['ps']) |
(fx['ps'] & fy['ze'])),
consequent=kpz['pb'], label='rule_kpz_pb')
rule_kpz_1 = ctrl.Rule(antecedent=((fx['ns'] & fy['ns']) |
(fx['ps'] & fy['ps']) |
(fx['ns'] & fy['ps']) |
(fx['ps'] & fy['ns'])),
consequent=kpz['ze'], label='rule_kpz_ze')
rule_kpz_2 = ctrl.Rule(antecedent=((fx['nb']) |
(fx['pb']) |
(fy['nb']) |
(fy['pb'])),
consequent=kpz['nb'], label='rule_kpz_nb')
system_kpz = ctrl.ControlSystem(rules=[rule_kpz_0, rule_kpz_1, rule_kpz_2])
sim_kpz = ctrl.ControlSystemSimulation(system_kpz, flush_after_run=self.num_mesh * self.num_mesh + 1)
# ===============================================================
rule_krx_0 = ctrl.Rule(antecedent=((mx['nb'] & fy['ze']) |
(mx['nb'] & fy['ns']) |
(mx['pb'] & fy['ze']) |
(mx['pb'] & fy['ps'])),
consequent=krx['pb'], label='rule_krx_pb')
rule_krx_1 = ctrl.Rule(antecedent=((mx['ze']) |
(mx['ns']) |
(mx['ps']) |
(mx['nb'] & fy['nb']) |
(mx['nb'] & fy['ps']) |
(mx['nb'] & fy['pb']) |
(mx['pb'] & fy['pb']) |
(mx['pb'] & fy['ns']) |
(mx['pb'] & fy['nb'])),
consequent=krx['nb'], label='rule_krx_ze')
system_krx = ctrl.ControlSystem(rules=[rule_krx_0, rule_krx_1])
sim_krx = ctrl.ControlSystemSimulation(system_krx, flush_after_run=self.num_mesh * self.num_mesh + 1)
# ===============================================================
rule_kry_0 = ctrl.Rule(antecedent=((my['nb'] & fx['ze']) |
(my['nb'] & fx['ns']) |
(my['pb'] & fx['ze']) |
(my['pb'] & fx['ps'])),
consequent=kry['pb'], label='rule_kry_pb')
rule_kry_1 = ctrl.Rule(antecedent=((my['ze']) |
(my['ns']) |
(my['ps']) |
(my['nb'] & fx['nb']) |
(my['pb'] & fx['pb']) |
(my['nb'] & fx['ps']) |
(my['pb'] & fx['ns']) |
(my['nb'] & fx['pb']) |
(my['pb'] & fx['nb'])),
consequent=kry['nb'], label='rule_kry_nb')
system_kry = ctrl.ControlSystem(rules=[rule_kry_0, rule_kry_1])
sim_kry = ctrl.ControlSystemSimulation(system_kry, flush_after_run=self.num_mesh * self.num_mesh + 1)
# ===============================================================
rule_krz_0 = ctrl.Rule(antecedent=((mz['nb'] & mx['ze']) |
(mz['nb'] & mx['ps']) |
(mz['nb'] & mx['ps']) |
(mz['pb'] & mx['ns']) |
(mz['pb'] & mx['ze']) |
(mz['pb'] & mx['ps'])),
consequent=krz['pb'], label='rule_krz_pb')
rule_krz_1 = ctrl.Rule(antecedent=((mz['ze']) |
(mz['ns']) |
(mz['ps']) |
(mz['nb'] & mx['nb']) |
(mz['pb'] & mx['pb']) |
(mz['nb'] & mx['pb']) |
(mz['pb'] & mx['nb'])),
consequent=krz['nb'], label='rule_krz_nb')
system_krz = ctrl.ControlSystem(rules=[rule_krz_0, rule_krz_1])
sim_krz = ctrl.ControlSystemSimulation(system_krz, flush_after_run=self.num_mesh * self.num_mesh + 1)
return sim_kpx, sim_kpy, sim_kpz, sim_krx, sim_kry, sim_krz
power['good'])
rule24 = ctrl.Rule(speed_w['good'] & radius['average'] & density['good'],
power['good'])
rule25 = ctrl.Rule(speed_w['good'] & radius['good'] & density['poor'],
power['good'])
rule26 = ctrl.Rule(speed_w['good'] & radius['good'] & density['average'],
power['excellent'])
rule27 = ctrl.Rule(speed_w['good'] & radius['good'] & density['good'],
power['excellent'])
tipping = ctrl.ControlSystem([
rule1, rule2, rule3, rule4, rule5, rule6, rule7, rule8, rule9, rule10,
rule11, rule12, rule13, rule14, rule15, rule16, rule17, rule18, rule19,
rule20, rule21, rule22, rule23, rule24, rule25, rule26, rule27
])
Tip = ctrl.ControlSystemSimulation(tipping)
print(
"*********************Wind Energy System using Fuzzy Interface*********************"
)
print("Wind Speed is in range 1-25m/s")
print("Length of wing is in range 19-90meters")
print("Air density is in the range 0.08-1.24 kg/m^3")
a = float(input("Enter the speed of wind m/s:"))
b = float(input("Enter the length of wing m:"))
c = float(input("Enter the density of air kg/m^3:"))
Tip.input['speed_w'] = a
Tip.input['radius'] = b
Tip.input['density'] = c
Tip.compute()
print("The Power Generated in Kilowatts:", Tip.output['power'])
x1['lo'] & x2['hi'] & x3['lo'] |
x1['md'] & x2['md'] & x3['lo'] |
x1['md'] & x2['md'] & x3['md'] |
x1['md'] & x2['md'] & x3['hi'],
y['md'])
r3 = ctrl.Rule(x1['hi'] & x2['hi'] & x3['hi'] |
x1['hi'] & x2['md'] & x3['hi'] |
x1['hi'] & x2['md'] & x3['md'] |
x1['md'] & x2['hi'] & x3['hi'] |
x1['md'] & x2['hi'] & x3['md'] |
x1['hi'] & x2['lo'] & x3['md'],
y['hi'])
myOutput_ctrl = ctrl.ControlSystem([r1, r2, r3])
myOutput = ctrl.ControlSystemSimulation(myOutput_ctrl)
i = 0
n = len(tabY)
mean_error = 0
while i < n:
myOutput.input['x1'] = tabX1[i]
myOutput.input['x2'] = tabX2[i]
myOutput.input['x3'] = tabX3[i]
myOutput.compute()
o = myOutput.output['y']
mean_error += (tabY[i] - o) ** 2
i += 1
def test_complex_system():
# A much more complex system, run multiple times & with array inputs
universe = np.linspace(-2, 2, 5)
error = ctrl.Antecedent(universe, 'error')
delta = ctrl.Antecedent(universe, 'delta')
output = ctrl.Consequent(universe, 'output')
names = ['nb', 'ns', 'ze', 'ps', 'pb']
error.automf(names=names)
delta.automf(names=names)
output.automf(names=names)
# The rulebase:
# rule 1: IF e = ZE AND delta = ZE THEN output = ZE
# rule 2: IF e = ZE AND delta = SP THEN output = SN
# rule 3: IF e = SN AND delta = SN THEN output = LP
# rule 4: IF e = LP OR delta = LP THEN output = LN
rule0 = ctrl.Rule(
antecedent=((error['nb'] & delta['nb']) | # This combination, or...
(error['ns'] & delta['nb']) | (error['nb'] & delta['ns'])),
consequent=output['nb'],
label='rule nb')
rule1 = ctrl.Rule(
antecedent=((error['nb'] & delta['ze']) | (error['nb'] & delta['ps']) |
(error['ns'] & delta['ns']) | (error['ns'] & delta['ze']) |
(error['ze'] & delta['ns']) | (error['ze'] & delta['nb']) |
(error['ps'] & delta['nb'])),
consequent=output['ns'],
label='rule ns')
rule2 = ctrl.Rule(
antecedent=((error['nb'] & delta['pb']) | (error['ns'] & delta['ps']) |
(error['ze'] & delta['ze']) | (error['ps'] & delta['ns']) |
(error['pb'] & delta['nb'])),
consequent=output['ze'],
label='rule ze')
rule3 = ctrl.Rule(
antecedent=((error['ns'] & delta['pb']) | (error['ze'] & delta['pb']) |
(error['ze'] & delta['ps']) | (error['ps'] & delta['ps']) |
(error['ps'] & delta['ze']) | (error['pb'] & delta['ze']) |
(error['pb'] & delta['ns'])),
consequent=output['ps'],
label='rule ps')
rule4 = ctrl.Rule(
antecedent=((error['ps'] & delta['pb']) | (error['pb'] & delta['pb']) |
(error['pb'] & delta['ps'])),
consequent=output['pb'],
label='rule pb')
system = ctrl.ControlSystem(rules=[rule0, rule1, rule2, rule3, rule4])
sim = ctrl.ControlSystemSimulation(system, cache=False)
x, y = np.meshgrid(np.linspace(-2, 2, 21), np.linspace(-2, 2, 21))
z0 = np.zeros_like(x)
z1 = np.zeros_like(x)
# The original, slow way - one set of values at a time
for i in range(21):
for j in range(21):
sim.input['error'] = x[i, j]
sim.input['delta'] = y[i, j]
sim.compute()
z0[i, j] = sim.output['output']
sim.reset()
# The new way - array inputs
sim.input['error'] = x
sim.input['delta'] = y
sim.compute()
z1 = sim.output['output']
# Ensure results align
np.testing.assert_allclose(z0, z1)
# Big expected array
expected = \
np.array([[ -1.66666667e+00, -1.65555556e+00, -1.62857143e+00,
-1.62857143e+00, -1.65555556e+00, -1.66666667e+00,
-1.34414414e+00, -1.18294574e+00, -1.10000000e+00,
-1.05641026e+00, -1.00000000e+00, -1.00000000e+00,
-1.00000000e+00, -1.00000000e+00, -1.00000000e+00,
-1.00000000e+00, -7.37704918e-01, -5.72916667e-01,
-4.27083333e-01, -2.62295082e-01, -2.77555756e-17],
[ -1.65555556e+00, -1.34414414e+00, -1.29494949e+00,
-1.29494949e+00, -1.34414414e+00, -1.34414414e+00,
-1.34414414e+00, -1.18294574e+00, -1.10000000e+00,
-1.05641026e+00, -1.00000000e+00, -7.37704918e-01,
-7.13580247e-01, -7.13580247e-01, -7.37704918e-01,
-7.37704918e-01, -4.36619718e-01, -2.91555556e-01,
-1.56140351e-01, 1.96914557e-16, 2.62295082e-01],
[ -1.62857143e+00, -1.29494949e+00, -1.18294574e+00,
-1.18294574e+00, -1.18294574e+00, -1.18294574e+00,
-1.18294574e+00, -1.18294574e+00, -1.10000000e+00,
-1.05333333e+00, -1.00000000e+00, -7.13580247e-01,
-5.72916667e-01, -5.72916667e-01, -5.72916667e-01,
-5.72916667e-01, -2.91555556e-01, -1.26984127e-01,
6.45478503e-17, 1.56140351e-01, 4.27083333e-01],
[ -1.62857143e+00, -1.29494949e+00, -1.18294574e+00,
-1.10000000e+00, -1.10000000e+00, -1.10000000e+00,
-1.10000000e+00, -1.10000000e+00, -1.10000000e+00,
-1.05333333e+00, -1.00000000e+00, -7.13580247e-01,
-5.72916667e-01, -4.27083333e-01, -4.27083333e-01,
-4.27083333e-01, -1.56140351e-01, 2.42054439e-16,
1.26984127e-01, 2.91555556e-01, 5.72916667e-01],
[ -1.65555556e+00, -1.34414414e+00, -1.18294574e+00,
-1.10000000e+00, -1.05641026e+00, -1.05641026e+00,
-1.05641026e+00, -1.05333333e+00, -1.05333333e+00,
-1.05641026e+00, -1.00000000e+00, -7.37704918e-01,
-5.72916667e-01, -4.27083333e-01, -2.62295082e-01,
-2.62295082e-01, 2.29733650e-16, 1.56140351e-01,
2.91555556e-01, 4.36619718e-01, 7.37704918e-01],
[ -1.66666667e+00, -1.34414414e+00, -1.18294574e+00,
-1.10000000e+00, -1.05641026e+00, -1.00000000e+00,
-1.00000000e+00, -1.00000000e+00, -1.00000000e+00,
-1.00000000e+00, -1.00000000e+00, -7.37704918e-01,
-5.72916667e-01, -4.27083333e-01, -2.62295082e-01,
-2.77555756e-17, 2.62295082e-01, 4.27083333e-01,
5.72916667e-01, 7.37704918e-01, 1.00000000e+00],
[ -1.34414414e+00, -1.34414414e+00, -1.18294574e+00,
-1.10000000e+00, -1.05641026e+00, -1.00000000e+00,
-7.37704918e-01, -7.13580247e-01, -7.13580247e-01,
-7.37704918e-01, -7.37704918e-01, -4.36619718e-01,
-2.91555556e-01, -1.56140351e-01, 4.17271323e-16,
2.62295082e-01, 2.62295082e-01, 4.27083333e-01,
5.72916667e-01, 7.37704918e-01, 1.00000000e+00],
[ -1.18294574e+00, -1.18294574e+00, -1.18294574e+00,
-1.10000000e+00, -1.05333333e+00, -1.00000000e+00,
-7.13580247e-01, -5.72916667e-01, -5.72916667e-01,
-5.72916667e-01, -5.72916667e-01, -2.91555556e-01,
-1.26984127e-01, 2.09780513e-16, 1.56140351e-01,
4.27083333e-01, 4.27083333e-01, 4.27083333e-01,
5.72916667e-01, 7.13580247e-01, 1.00000000e+00],
[ -1.10000000e+00, -1.10000000e+00, -1.10000000e+00,
-1.10000000e+00, -1.05333333e+00, -1.00000000e+00,
-7.13580247e-01, -5.72916667e-01, -4.27083333e-01,
-4.27083333e-01, -4.27083333e-01, -1.56140351e-01,
2.42054439e-16, 1.26984127e-01, 2.91555556e-01,
5.72916667e-01, 5.72916667e-01, 5.72916667e-01,
5.72916667e-01, 7.13580247e-01, 1.00000000e+00],
[ -1.05641026e+00, -1.05641026e+00, -1.05333333e+00,
-1.05333333e+00, -1.05641026e+00, -1.00000000e+00,
-7.37704918e-01, -5.72916667e-01, -4.27083333e-01,
-2.62295082e-01, -2.62295082e-01, 2.29733650e-16,
1.56140351e-01, 2.91555556e-01, 4.36619718e-01,
7.37704918e-01, 7.37704918e-01, 7.13580247e-01,
7.13580247e-01, 7.37704918e-01, 1.00000000e+00],
[ -1.00000000e+00, -1.00000000e+00, -1.00000000e+00,
-1.00000000e+00, -1.00000000e+00, -1.00000000e+00,
-7.37704918e-01, -5.72916667e-01, -4.27083333e-01,
-2.62295082e-01, -2.77555756e-17, 2.62295082e-01,
4.27083333e-01, 5.72916667e-01, 7.37704918e-01,
1.00000000e+00, 1.00000000e+00, 1.00000000e+00,
1.00000000e+00, 1.00000000e+00, 1.00000000e+00],
[ -1.00000000e+00, -7.37704918e-01, -7.13580247e-01,
-7.13580247e-01, -7.37704918e-01, -7.37704918e-01,
-4.36619718e-01, -2.91555556e-01, -1.56140351e-01,
2.29733650e-16, 2.62295082e-01, 2.62295082e-01,
4.27083333e-01, 5.72916667e-01, 7.37704918e-01,
1.00000000e+00, 1.05641026e+00, 1.05333333e+00,
1.05333333e+00, 1.05641026e+00, 1.05641026e+00],
[ -1.00000000e+00, -7.13580247e-01, -5.72916667e-01,
-5.72916667e-01, -5.72916667e-01, -5.72916667e-01,
-2.91555556e-01, -1.26984127e-01, 2.42054439e-16,
1.56140351e-01, 4.27083333e-01, 4.27083333e-01,
4.27083333e-01, 5.72916667e-01, 7.13580247e-01,
1.00000000e+00, 1.05333333e+00, 1.10000000e+00,
1.10000000e+00, 1.10000000e+00, 1.10000000e+00],
[ -1.00000000e+00, -7.13580247e-01, -5.72916667e-01,
-4.27083333e-01, -4.27083333e-01, -4.27083333e-01,
-1.56140351e-01, 2.09780513e-16, 1.26984127e-01,
2.91555556e-01, 5.72916667e-01, 5.72916667e-01,
5.72916667e-01, 5.72916667e-01, 7.13580247e-01,
1.00000000e+00, 1.05333333e+00, 1.10000000e+00,
1.18294574e+00, 1.18294574e+00, 1.18294574e+00],
[ -1.00000000e+00, -7.37704918e-01, -5.72916667e-01,
-4.27083333e-01, -2.62295082e-01, -2.62295082e-01,
4.17271323e-16, 1.56140351e-01, 2.91555556e-01,
4.36619718e-01, 7.37704918e-01, 7.37704918e-01,
7.13580247e-01, 7.13580247e-01, 7.37704918e-01,
1.00000000e+00, 1.05641026e+00, 1.10000000e+00,
1.18294574e+00, 1.34414414e+00, 1.34414414e+00],
[ -1.00000000e+00, -7.37704918e-01, -5.72916667e-01,
-4.27083333e-01, -2.62295082e-01, -2.77555756e-17,
2.62295082e-01, 4.27083333e-01, 5.72916667e-01,
7.37704918e-01, 1.00000000e+00, 1.00000000e+00,
1.00000000e+00, 1.00000000e+00, 1.00000000e+00,
1.00000000e+00, 1.05641026e+00, 1.10000000e+00,
1.18294574e+00, 1.34414414e+00, 1.66666667e+00],
[ -7.37704918e-01, -4.36619718e-01, -2.91555556e-01,
-1.56140351e-01, 2.29733650e-16, 2.62295082e-01,
2.62295082e-01, 4.27083333e-01, 5.72916667e-01,
7.37704918e-01, 1.00000000e+00, 1.05641026e+00,
1.05333333e+00, 1.05333333e+00, 1.05641026e+00,
1.05641026e+00, 1.05641026e+00, 1.10000000e+00,
1.18294574e+00, 1.34414414e+00, 1.65555556e+00],
[ -5.72916667e-01, -2.91555556e-01, -1.26984127e-01,
2.42054439e-16, 1.56140351e-01, 4.27083333e-01,
4.27083333e-01, 4.27083333e-01, 5.72916667e-01,
7.13580247e-01, 1.00000000e+00, 1.05333333e+00,
1.10000000e+00, 1.10000000e+00, 1.10000000e+00,
1.10000000e+00, 1.10000000e+00, 1.10000000e+00,
1.18294574e+00, 1.29494949e+00, 1.62857143e+00],
[ -4.27083333e-01, -1.56140351e-01, 6.45478503e-17,
1.26984127e-01, 2.91555556e-01, 5.72916667e-01,
5.72916667e-01, 5.72916667e-01, 5.72916667e-01,
7.13580247e-01, 1.00000000e+00, 1.05333333e+00,
1.10000000e+00, 1.18294574e+00, 1.18294574e+00,
1.18294574e+00, 1.18294574e+00, 1.18294574e+00,
1.18294574e+00, 1.29494949e+00, 1.62857143e+00],
[ -2.62295082e-01, 1.96914557e-16, 1.56140351e-01,
2.91555556e-01, 4.36619718e-01, 7.37704918e-01,
7.37704918e-01, 7.13580247e-01, 7.13580247e-01,
7.37704918e-01, 1.00000000e+00, 1.05641026e+00,
1.10000000e+00, 1.18294574e+00, 1.34414414e+00,
1.34414414e+00, 1.34414414e+00, 1.29494949e+00,
1.29494949e+00, 1.34414414e+00, 1.65555556e+00],
[ -2.77555756e-17, 2.62295082e-01, 4.27083333e-01,
5.72916667e-01, 7.37704918e-01, 1.00000000e+00,
1.00000000e+00, 1.00000000e+00, 1.00000000e+00,
1.00000000e+00, 1.00000000e+00, 1.05641026e+00,
1.10000000e+00, 1.18294574e+00, 1.34414414e+00,
1.66666667e+00, 1.65555556e+00, 1.62857143e+00,
1.62857143e+00, 1.65555556e+00, 1.66666667e+00]])
# Ensure results are within expected limits
np.testing.assert_allclose(z1, expected)
pwm['terang'] = fuzz.trimf(pwm.universe, [191, 255, 255])
# Plot grafik derajat keanggotaan
intensitas.view()
pwm.view()
# Rules
rule1 = ctrl.Rule(intensitas['gelap'], pwm['terang'])
rule2 = ctrl.Rule(intensitas['redup'], pwm['agak_terang'])
rule3 = ctrl.Rule(intensitas['agak_redup'], pwm['agak_redup'])
rule4 = ctrl.Rule(intensitas['agak_terang'], pwm['redup'])
rule5 = ctrl.Rule(intensitas['terang'], pwm['mati'])
# Persiapan untuk defuzzifikasi
pwm_ctrl = ctrl.ControlSystem([rule1, rule2, rule3, rule4, rule5])
nilai_pwm = ctrl.ControlSystemSimulation(pwm_ctrl)
# Input data
input_jml_orang = input("Masukan jumlah orang dalam ruangan : ")
input_intensitas = input("Masukan intensitas cahaya dalam ruangan dalam lux (lx) : ")
# Jika ada orang di dalam ruangan
if (int(input_jml_orang) > 0) :
# Defuzzifikasi
nilai_pwm.input['intensitas'] = int(input_intensitas)
nilai_pwm.compute()
# Plot grafik
intensitas.view(sim=nilai_pwm)
pwm.view(sim=nilai_pwm)
def __init__(self, ctrl, ante, cons):
self.ctrl = ctrl
self.ante = ante
self.cons = cons
self.simulation = control.ControlSystemSimulation(self.ctrl)
def test_multiple_rules_same_consequent_term():
# 2 input variables, 1 output variable and 7 instances.
x1_inputs = [0.6, 0.2, 0.4, 0.7, 1, 1.2, 1.8]
x2_inputs = [0.9, 1, 0.8, 0, 1.2, 0.6, 1.8]
dom = np.arange(0, 2.1, 0.01)
x1 = ctrl.Antecedent(dom, "x1")
x1['label0'] = fuzz.trimf(x1.universe, (0.2, 0.2, 0.6))
x1['label1'] = fuzz.trimf(x1.universe, (0.2, 0.6, 1.0))
x1['label2'] = fuzz.trimf(x1.universe, (0.6, 1.0, 1.4))
x1['label3'] = fuzz.trimf(x1.universe, (1.0, 1.4, 1.8))
x1['label4'] = fuzz.trimf(x1.universe, (1.4, 1.8, 1.8))
x2 = ctrl.Antecedent(dom, "x2")
x2['label0'] = fuzz.trimf(x2.universe, (0.0, 0.0, 0.45))
x2['label1'] = fuzz.trimf(x2.universe, (0.0, 0.45, 0.9))
x2['label2'] = fuzz.trimf(x2.universe, (0.45, 0.9, 1.35))
x2['label3'] = fuzz.trimf(x2.universe, (0.9, 1.35, 1.8))
x2['label4'] = fuzz.trimf(x2.universe, (1.35, 1.8, 1.8))
y = ctrl.Consequent(dom, "y")
y['label0'] = fuzz.trimf(y.universe, (0.3, 0.3, 0.725))
y['label1'] = fuzz.trimf(y.universe, (0.3, 0.725, 1.15))
y['label2'] = fuzz.trimf(y.universe, (0.725, 1.15, 1.575))
y['label3'] = fuzz.trimf(y.universe, (1.15, 1.575, 2.0))
y['label4'] = fuzz.trimf(y.universe, (1.575, 2.0, 2.0))
r1 = ctrl.Rule(x1['label0'] & x2['label2'], y['label0'])
r2 = ctrl.Rule(x1['label1'] & x2['label0'], y['label0'])
r3 = ctrl.Rule(x1['label1'] & x2['label2'], y['label0'])
# Equivalent to above 3 rules
r123 = ctrl.Rule(
(x1['label0'] & x2['label2']) | (x1['label1'] & x2['label0']) |
(x1['label1'] & x2['label2']), y['label0'])
r4 = ctrl.Rule(x1['label2'] & x2['label1'], y['label2'])
r5 = ctrl.Rule(x1['label2'] & x2['label3'], y['label3'])
r6 = ctrl.Rule(x1['label4'] & x2['label4'], y['label4'])
# Build a system with three rules targeting the same Consequent Term,
# and then an equivalent system with those three rules combined into one.
cs0 = ctrl.ControlSystem([r1, r2, r3, r4, r5, r6])
cs1 = ctrl.ControlSystem([r123, r4, r5, r6])
expected_results = [
0.438372093023, 0.443962536855, 0.461436409933, 0.445290345769, 1.575,
1.15, 1.86162790698
]
# Ensure the results are equivalent within error
for inst, expected in zip(range(7), expected_results):
sim0 = ctrl.ControlSystemSimulation(cs0)
sim1 = ctrl.ControlSystemSimulation(cs1)
sim0.input["x1"] = x1_inputs[inst]
sim0.input["x2"] = x2_inputs[inst]
sim1.input["x1"] = x1_inputs[inst]
sim1.input["x2"] = x2_inputs[inst]
sim0.compute()
sim1.compute()
tst.assert_allclose(sim0.output['y'], sim1.output['y'])
tst.assert_allclose(expected, sim0.output['y'], atol=1e-4, rtol=1e-4)
def createContorller():
# Fuzzy membership centers [-2 -1 0 1 2]
# Create the three fuzzy variables - two inputs, one output
universe = np.linspace(-2, 2, 5)
error = ctrl.Antecedent(universe, 'error')
names = ['nb', 'ns', 'z', 'ps', 'pb']
error.automf(names=names)
delta = ctrl.Antecedent(universe, 'delta')
delta.automf(names=names)
output = ctrl.Consequent(universe, 'output')
output.automf(names=names)
# Name fuzzy variables
# Rule 0: if the error is big negative and changing in the wrong direction, then output is big positive
rule0 = ctrl.Rule(
antecedent=((error['nb'] & delta['nb']) | (error['ns'] & delta['nb']) |
(error['nb'] & delta['ns']) | (error['z'] & delta['nb']) |
(error['nb'] & delta['z'])),
consequent=output['pb'],
label='rule pb')
# Rule 1: For somewhat more favourable combinations the output is small positive
rule1 = ctrl.Rule(
antecedent=((error['ns'] & delta['ns']) | (error['ns'] & delta['z']) |
(error['nb'] & delta['ps']) | (error['ps'] & delta['nb']) |
(error['z'] & delta['ns'])),
consequent=output['ps'],
label='rule ps')
# Rule 2: For good errors and good changes, the output is zero
rule2 = ctrl.Rule(
antecedent=((error['z'] & delta['z']) | (error['ns'] & delta['ps']) |
(error['nb'] & delta['pb']) | (error['ps'] & delta['ns']) |
(error['pb'] & delta['nb'])),
consequent=output['z'],
label='rule z')
# Rule 3: For somewhat less favourable combinations the output is small negative
rule3 = ctrl.Rule(
antecedent=((error['ps'] & delta['ps']) | (error['ps'] & delta['z']) |
(error['pb'] & delta['ns']) | (error['ns'] & delta['pb']) |
(error['z'] & delta['ps'])),
consequent=output['ns'],
label='rule ns')
# Rule 4: if the error is big positive and changing in the wrong direction, then output is big negative
rule4 = ctrl.Rule(
antecedent=((error['pb'] & delta['pb']) | (error['ps'] & delta['pb']) |
(error['pb'] & delta['ps']) | (error['z'] & delta['pb']) |
(error['pb'] & delta['z'])),
consequent=output['nb'],
label='rule nb')
# Create fuzzy controller
system = ctrl.ControlSystem(rules=[rule0, rule1, rule2, rule3, rule4])
controller = ctrl.ControlSystemSimulation(system)
# Return fuzzy simulator
return controller
def Defuzz(self):
# New Antecedent/Consequent objects hold universe variables and membership
# functions
batt_percent = ctrl.Antecedent(np.arange(0, 100, 1),
'Battery_percentage')
temp = ctrl.Antecedent(np.arange(15, 30, 1), 'Temperature')
cloud_cover = ctrl.Antecedent(np.arange(0, 1, 0.01), 'Cloud_cover')
eco_level = ctrl.Consequent(np.arange(1, 4, 0.01), 'Economy_level')
# Battery membership function population
batt_percent['Low_battery'] = fuzz.trapmf(batt_percent.universe,
[0, 0, 20, 30])
batt_percent['Medium_battery'] = fuzz.trapmf(batt_percent.universe,
[20, 25, 75, 80])
batt_percent['High_battery'] = fuzz.trapmf(batt_percent.universe,
[75, 80, 100, 100])
# Temperature membership function population
temp['Low_temperature'] = fuzz.trapmf(temp.universe, [0, 0, 18, 20])
temp['Medium_temperature'] = fuzz.trapmf(temp.universe,
[18, 20, 24, 26])
temp['High_temperature'] = fuzz.trapmf(temp.universe, [24, 26, 30, 30])
# Cloud_cover membership function population
cloud_cover['Minimum_clouds'] = fuzz.trapmf(cloud_cover.universe,
[0, 0, 0.20, 0.25])
cloud_cover['Medium_clouds'] = fuzz.trapmf(cloud_cover.universe,
[0.20, 0.25, 0.65, 0.70])
cloud_cover['High_clouds'] = fuzz.trapmf(cloud_cover.universe,
[0.65, 0.70, 1, 1])
# Custom membership functions can be built interactively with a familiar,
# Pythonic API
eco_level['Critical'] = fuzz.trimf(eco_level.universe, [0, 1.0, 2.0])
eco_level['Alert'] = fuzz.trimf(eco_level.universe, [1.75, 2.25, 2.75])
eco_level['Normal'] = fuzz.trimf(eco_level.universe, [2.5, 3.0, 3.5])
eco_level['Economyless'] = fuzz.trimf(eco_level.universe,
[3.25, 4.0, 5.0])
# Rules
rule1 = ctrl.Rule(
batt_percent['Low_battery'] & (~temp['High_temperature']),
eco_level['Critical'])
rule2 = ctrl.Rule(
batt_percent['Low_battery'] & temp['High_temperature']
& cloud_cover['High_clouds'], eco_level['Critical'])
rule3 = ctrl.Rule(
batt_percent['Low_battery'] & temp['High_temperature'] &
(~cloud_cover['High_clouds']), eco_level['Alert'])
rule4 = ctrl.Rule(
batt_percent['Medium_battery'] & temp['Low_temperature'] &
(~cloud_cover['High_clouds']), eco_level['Alert'])
rule5 = ctrl.Rule(
batt_percent['Medium_battery'] & temp['Low_temperature']
& cloud_cover['High_clouds'], eco_level['Critical'])
rule6 = ctrl.Rule(
batt_percent['Medium_battery'] & (~temp['Low_temperature']) &
(~cloud_cover['High_clouds']), eco_level['Normal'])
rule7 = ctrl.Rule(
batt_percent['Medium_battery'] & (~temp['Low_temperature'])
& cloud_cover['High_clouds'], eco_level['Alert'])
rule8 = ctrl.Rule(
batt_percent['High_battery'] & temp['Low_temperature'] &
(~cloud_cover['High_clouds']), eco_level['Normal'])
rule9 = ctrl.Rule(
batt_percent['High_battery'] & temp['Low_temperature']
& cloud_cover['High_clouds'], eco_level['Alert'])
rule10 = ctrl.Rule(
batt_percent['High_battery'] & (~temp['Low_temperature']) &
(~cloud_cover['High_clouds']), eco_level['Economyless'])
rule11 = ctrl.Rule(
batt_percent['High_battery'] & (~temp['Low_temperature'])
& cloud_cover['High_clouds'], eco_level['Normal'])
eco_ctrl = ctrl.ControlSystem([
rule1, rule2, rule3, rule4, rule5, rule6, rule7, rule8, rule9,
rule10, rule11
])
eco_mode = ctrl.ControlSystemSimulation(eco_ctrl)
# Pass inputs to the ControlSystem using Antecedent labels with Pythonic API
# Note: if you like passing many inputs all at once, use .inputs(dict_of_data)
eco_mode.input['Temperature'] = self.t
eco_mode.input['Cloud_cover'] = self.c
eco_mode.input['Battery_percentage'] = self.b
# Crunch the numbers
eco_mode.compute()
defuzz = eco_mode.output['Economy_level']
self.defuzz.setText(format(defuzz, '.2f'))
self.eco = int(defuzz + 0.5)
import numpy as np
import skfuzzy as fuzz
from skfuzzy import control as ctrl
from rules import rule1, rule2, rule3, rule4, rule5, rule6, rule7, rule8, rule9, rule10
system = ctrl.ControlSystem(rules=[
rule1, rule2, rule3, rule4, rule5, rule6, rule7, rule8, rule9, rule10
])
diagnosis = ctrl.ControlSystemSimulation(system)
"""
COVID-19=[40.28, 0.4128, 0.5805, 0.4942, 0.1437, 0.1802, 0.4195, 0.9128, 0.1782]
Alergias=[36.78, 0.1105, 0.08621, 0.1453, 0.8563, 0.8314, 0.1437, 0.5523, 0.6264]
Resfriado=[37.7, 0.3779, 0.3161, 0.1686, 0.9138, 0.8779, 0.8563, 0.2151, 0.9138]
Influenza=[40.22, 0.8779, 0.8908, 0.9012, 0.3046, 0.1337, 0.4425, 0.1221, 0.4655]
COVID-19=[38.4, 0, 0, 1, 0, 0, 0, 1, 0]
"""
inputs = [37.7, 0.3779, 0.3161, 0.1686, 0.9138, 0.8779, 0.8563, 0.2151, 0.9138]
diagnosis.input['Fiebre'] = inputs[0]
diagnosis.input['DolorCabeza'] = inputs[1]
diagnosis.input['Mialgia'] = inputs[2]
diagnosis.input['Fatiga'] = inputs[3]
diagnosis.input['CongestionNasal'] = inputs[4]
diagnosis.input['Estornudos'] = inputs[5]
diagnosis.input['DolorGarganta'] = inputs[6]
diagnosis.input['Diarrea'] = inputs[7]
rule21 = ctrl.Rule(mobility_failure['low'], architecture['2tier'])
rule42 = ctrl.Rule(no_of_task['high'], architecture['3tier'])
rule41 = ctrl.Rule(no_of_task['low'], architecture['2tier'])
architecturing_ctrl = ctrl.ControlSystem(rules=[
rule21,
rule22,
rule31,
rule32,
rule41,
rule42,
rule11,
rule12,
])
architecturing = ctrl.ControlSystemSimulation(architecturing_ctrl)
architecturing.input['device_count'] = 1600 #2
architecturing.input['no_of_task'] = 110256 #2
architecturing.input['LAN_delay'] = 60 #3
architecturing.input['mobility_failure'] = 16.8 #3
# Crunch the numbers
architecturing.compute()
print(architecturing.output['architecture'])
output = architecturing.output['architecture']
if (output > 50):
print("Edge Should be introduced")
else:
ruleVH2 = ctrl.Rule(temperature['VH'] | humidity['H'], power['VH'])
ruleVH3 = ctrl.Rule(temperature['VVH'] | humidity['H'], power['VH'])
ruleVH4 = ctrl.Rule(temperature['H'] | humidity['VH'], power['VH'])
ruleVH5 = ctrl.Rule(temperature['VH'] | humidity['VH'], power['VH'])
ruleVH6 = ctrl.Rule(temperature['F'] | humidity['VVH'], power['VH'])
ruleVH7 = ctrl.Rule(temperature['H'] | humidity['VVH'], power['VH'])
ruleVVH1 = ctrl.Rule(temperature['VVH'] | humidity['VH'], power['VVH'])
ruleVVH2 = ctrl.Rule(temperature['VH'] | humidity['VVH'], power['VVH'])
ruleVVH3 = ctrl.Rule(temperature['VVH'] | humidity['VVH'], power['VVH'])
power_ctrl = ctrl.ControlSystem([ruleL1, ruleL2, ruleL3, ruleL4, ruleL5, ruleM1, ruleVL1, ruleVL2, ruleVL3, ruleVL4,
ruleVL5, ruleVL6, ruleVL7, ruleVVL1, ruleVVL2, ruleVVL3, ruleM2, ruleM3, ruleM4,
ruleM5, ruleM6, ruleM7, ruleH1, ruleH2, ruleH3, ruleH4, ruleH5, ruleH6, ruleH7,
ruleH8, ruleH9, ruleH10, ruleH11, ruleVH1, ruleVH2, ruleVH3, ruleVH4, ruleVH5,
ruleVH6, ruleVH7, ruleVVH1, ruleVVH2, ruleVVH3])
power_check = ctrl.ControlSystemSimulation(power_ctrl)
power_check.input['temperature'] = 40
power_check.input['humidity'] = 37
power_check.compute()
print(power_check.output['power'])
#power.view(sim=power_check)
rule46 = ctrl.Rule(angle['excellent']& angular_vel['average'], force['excellent'])
rule47 = ctrl.Rule(angle['excellent']& angular_vel['decent'], force['excellent'])
rule48 = ctrl.Rule(angle['excellent']& angular_vel['good'], force['excellent'])
rule49 = ctrl.Rule(angle['excellent']& angular_vel['excellent'], force['excellent'])
force_cntrl = ctrl.ControlSystem([
rule01, rule02, rule03, rule04, rule05, rule06, rule07,
rule08, rule09, rule10, rule11, rule12, rule13, rule14,
rule15, rule16, rule17, rule18, rule19, rule20, rule21,
rule22, rule23, rule24, rule25, rule26, rule27, rule28,
rule29, rule30, rule31, rule32, rule33, rule34, rule35,
rule36, rule37, rule38, rule39, rule40, rule41, rule42,
rule43, rule44, rule45, rule46, rule47, rule48, rule49
])
fuzzy_force = ctrl.ControlSystemSimulation(force_cntrl)
def uforce(statevec):
global fuzzy_force
fuzzy_force.input['angle'] = (statevec[2]*180. / np.pi) - 90
fuzzy_force.input['angular_vel'] = statevec[3]
fuzzy_force.compute()
return fuzzy_force.output['force']
def func2(t, y):
g = 9.8 # Gravitational Acceleration
L = 1.5 # Length of pendulum
m = 1.0 #mass of bob (kg)
M = 2.0 # mass of cart (kg)
x_ddot = uforce(y) - m*L*y[3]*y[3] * np.cos( y[2] ) + m*g*np.cos(y[2]) * np.sin(y[2])
epilepsy['high'] = fuzz.trimf(epilepsy.universe, [0.5, 0.75, 1])
# You can see how these look with .view()
epilepsy.view()
plt.show()
rule1 = ctrl.Rule(x['poor'] & y['average'] & z['good'], epilepsy['low'])
rule2 = ctrl.Rule(x['average'] & y['average'] & z['average'], epilepsy['medium'])
rule3 = ctrl.Rule(x['poor'] & y['poor'] & z['good'], epilepsy['high'])
#rule1.view()
epilepsyping_ctrl = ctrl.ControlSystem([rule1, rule2, rule3])
epilepsyping = ctrl.ControlSystemSimulation(epilepsyping_ctrl)
# Pass inputs to the ControlSystem using Antecedent labels with Pythonic API
# Note: if you like passing many inputs all at once, use .inputs(dict_of_data)
#out_1 = np.where(out > 0,1,-1)
#out_1 = out_1.T
#np.savetxt("foo_4.csv", out_1, delimiter=",")
#for i in range(0,dataset_x.size):
epilepsyping.input['x'] = dataset_X[4]
tipo['0'] = fuzz.trimf(tipo.universe, [0, 0, 1])
tipo['1'] = fuzz.trimf(tipo.universe, [0.5, 1, 1.5])
tipo['2'] = fuzz.trimf(tipo.universe, [1.5, 2, 2])
#Regras da defuzzificação
rule1 = ctrl.Rule(Lpetala['p'], tipo['0'])
rule2 = ctrl.Rule(Lpetala['m'] & (Cpetala['pp'] | Cpetala['p'] | Cpetala['m']),
tipo['1'])
rule3 = ctrl.Rule(
(Lpetala['g'] | Lpetala['mg'] | Lpetala['gg'] | Lpetala['m2']) &
(Cpetala['g'] | Cpetala['mg']), tipo['2'])
#Comandos de simulação
tipo_ctrl = ctrl.ControlSystem([rule1, rule2, rule3])
tipo_simulador = ctrl.ControlSystemSimulation(tipo_ctrl)
#Abertura do datasheet
iris = load_iris()
df_iris = pd.DataFrame(np.column_stack((iris.data, iris.target)),
columns=iris.feature_names + ['target'])
df_iris.describe()
#df_iris.plot()
X = []
for o in range(0, 150, 1):
print(o)
a = df_iris.loc[[o], ['petal width (cm)']]
b = df_iris.loc[[o], ['petal length (cm)']]
(position['pb'] & velocity['ns'])),
consequent=output['ps'],
label='rule ps')
rule4 = ctrl.Rule(antecedent=((position['ps'] & velocity['pb']) |
(position['pb'] & velocity['pb']) |
(position['pb'] & velocity['ps'])),
consequent=output['pb'],
label='rule pb')
system = ctrl.ControlSystem(rules=[rule0, rule1, rule2, rule3, rule4])
# Later we intend to run this system with a 21*21 set of inputs, so we allow
# that many plus one unique runs before results are flushed.
# Subsequent runs would return in 1/8 the time!
sim = ctrl.ControlSystemSimulation(system)
# Initilize sim
env = Continuous_MountainCarEnv()
obs = env.reset()
GOAL_POS = env.goal_position
done = False
while not done:
env.render()
pos = (obs[0] + 1.2) / 1.8
vel = ((obs[1] * 10) + 0.7) / 1.4
print("Posicion y velocidad: " + str(pos) + " | " + str(vel)) #DEBUG
# Set input to fuzzy control
def __init__(self):
self.simulate_eggs = ctrl.Consequent(np.arange(0, 3000, 1), 'eggs')
self.temperature = ctrl.Antecedent(np.arange(0, 40, 1), 'temperature')
self.pollen = ctrl.Antecedent(np.arange(0, 14, 1), 'pollen')
self.day_length = ctrl.Antecedent(np.arange(8, 18, 1), 'day length')
self.bees_num = ctrl.Antecedent(np.arange(1, 80000, 1), 'bees num')
self.pollen['poor'] = fuzz.trimf(self.pollen.universe, [0, 0, 4])
self.pollen['average'] = fuzz.trimf(self.pollen.universe, [3, 6.5, 10])
self.pollen['good'] = fuzz.trimf(self.pollen.universe, [9, 14, 14])
self.temperature['low'] = fuzz.trimf(self.temperature.universe, [0, 0, 15])
self.temperature['medium'] = fuzz.trimf(self.temperature.universe, [14, 20, 26])
self.temperature['high'] = fuzz.trimf(self.temperature.universe, [25, 40, 40])
self.day_length['short'] = fuzz.trimf(self.day_length.universe, [8, 8, 12])
self.day_length['average'] = fuzz.trimf(self.day_length.universe, [11, 13, 15])
self.day_length['long'] = fuzz.trimf(self.day_length.universe, [14, 17, 17])
self.bees_num['little'] = fuzz.trimf(self.bees_num.universe, [0, 0, 26000])
self.bees_num['medium'] = fuzz.trimf(self.bees_num.universe, [25000, 40000, 55000])
self.bees_num['a lot'] = fuzz.trimf(self.bees_num.universe, [54000, 80000, 80000])
self.simulate_eggs['none'] = fuzz.trimf(self.simulate_eggs.universe, [0, 0, 50])
self.simulate_eggs['very little'] = fuzz.trimf(self.simulate_eggs.universe, [49, 250, 500])
self.simulate_eggs['little'] = fuzz.trimf(self.simulate_eggs.universe, [450, 750, 1050])
self.simulate_eggs['medium'] = fuzz.trimf(self.simulate_eggs.universe, [1000, 1300, 1600])
self.simulate_eggs['many'] = fuzz.trimf(self.simulate_eggs.universe, [1500, 1900, 2300])
self.simulate_eggs['a lot'] = fuzz.trimf(self.simulate_eggs.universe, [2200, 3000, 3000])
rule1 = ctrl.Rule(self.day_length['short'] & self.temperature['low'], self.simulate_eggs['none'])
rule2 = ctrl.Rule(self.day_length['short'] & self.temperature['medium'] & self.pollen['average'],
self.simulate_eggs['little'])
rule3 = ctrl.Rule(
self.day_length['short'] & self.temperature['high'] & (self.pollen['average'] | self.pollen['good']),
self.simulate_eggs['medium'])
rule4 = ctrl.Rule(self.day_length['short'] & self.temperature['medium'] & self.pollen['good'],
self.simulate_eggs['medium'])
rule5 = ctrl.Rule(
self.day_length['long'] & self.temperature['low'] & (self.pollen['average'] | self.pollen['good']),
self.simulate_eggs['very little'])
rule6 = ctrl.Rule(
self.day_length['average'] & self.temperature['low'] & (self.pollen['average'] | self.pollen['good']),
self.simulate_eggs['very little'])
rule7 = ctrl.Rule(self.day_length['average'] & self.temperature['medium'] & self.pollen['average'],
self.simulate_eggs['little'])
rule8 = ctrl.Rule(self.day_length['average'] & self.temperature['medium'] & self.pollen['good'],
self.simulate_eggs['medium'])
rule9 = ctrl.Rule(
self.day_length['average'] & self.temperature['high'] & (self.pollen['average'] | self.pollen['good']),
self.simulate_eggs['many'])
rule10 = ctrl.Rule(self.day_length['long'] & self.temperature['medium'] & (self.pollen['average']),
self.simulate_eggs['many'])
rule11 = ctrl.Rule((self.day_length['average'] | self.day_length['long']) & (
self.temperature['high'] | self.temperature['medium']) &
(self.pollen['average'] | self.pollen['good']) & self.bees_num['little'],
self.simulate_eggs['little'])
rule12 = ctrl.Rule((self.day_length['average'] | self.day_length['long']) & (
self.temperature['high'] | self.temperature['medium']) &
(self.pollen['average'] | self.pollen['good']) & self.bees_num['medium'],
self.simulate_eggs['medium'])
rule13 = ctrl.Rule((self.day_length['average'] | self.day_length['long']) & (
self.temperature['high'] | self.temperature['medium']) &
(self.pollen['average'] | self.pollen['good']) & self.bees_num['a lot'],
self.simulate_eggs['a lot'])
rule14 = ctrl.Rule(self.day_length['long'] & self.temperature['high'] & self.pollen['average'],
self.simulate_eggs['many'])
rule15 = ctrl.Rule(self.day_length['long'] & self.temperature['high'] & self.pollen['good'],
self.simulate_eggs['a lot'])
rule16 = ctrl.Rule(self.bees_num['little'], self.simulate_eggs['none'])
rule17 = ctrl.Rule(self.bees_num['little'] & self.pollen['poor'], self.simulate_eggs['none'])
rule18 = ctrl.Rule(self.pollen['poor'], self.simulate_eggs['none'])
eggs_ctrl = ctrl.ControlSystem([rule1, rule2, rule3, rule4, rule5, rule6, rule7, rule8, rule9, rule10, rule11,
rule12, rule13, rule14, rule15, rule16, rule17, rule18])
self.laying_eggs = ctrl.ControlSystemSimulation(eggs_ctrl)
def createFuzzy(self):
self.fuzz_pend1 = ctrl.Antecedent(np.arange(-1.5, 1.6, 0.1), 'join1')
self.fuzz_pend1_v = ctrl.Antecedent(np.arange(-10, 10, 0.1), 'pend1_v')
self.fuzz_motor = ctrl.Consequent(np.arange(-150, 150, 1), 'motor')
self.fuzz_position = ctrl.Antecedent(np.arange(-13, 13, 0.1),
'position')
self.fuzz_vv2 = ctrl.Antecedent(np.arange(-10, 10, 0.1), 'v')
self.fuzz_motor2 = ctrl.Consequent(np.arange(-100, 100, 1), 'motor2')
self.fuzz_pend1['poor'] = fuzz.zmf(self.fuzz_pend1.universe, -0.2,
-0.1)
self.fuzz_pend1['mediocre'] = fuzz.trimf(self.fuzz_pend1.universe,
[-0.2, -0.1, 0])
self.fuzz_pend1['average'] = fuzz.trimf(self.fuzz_pend1.universe,
[-0.1, 0, 0.1])
self.fuzz_pend1['decent'] = fuzz.trimf(self.fuzz_pend1.universe,
[0, 0.1, 0.2])
self.fuzz_pend1['good'] = fuzz.smf(self.fuzz_pend1.universe, 0.1, 0.2)
self.fuzz_pend1_v['poor'] = fuzz.zmf(self.fuzz_pend1_v.universe, -2,
-1)
self.fuzz_pend1_v['mediocre'] = fuzz.trimf(self.fuzz_pend1_v.universe,
[-2, -1, 0])
self.fuzz_pend1_v['average'] = fuzz.trimf(self.fuzz_pend1_v.universe,
[-1, 0, 1])
self.fuzz_pend1_v['decent'] = fuzz.trimf(self.fuzz_pend1_v.universe,
[0, 1, 2])
self.fuzz_pend1_v['good'] = fuzz.smf(self.fuzz_pend1_v.universe, 1, 2)
self.fuzz_motor['poor'] = fuzz.zmf(self.fuzz_motor.universe, -50, -20)
self.fuzz_motor['average'] = fuzz.trimf(self.fuzz_motor.universe,
[-50, 0, 50])
self.fuzz_motor['good'] = fuzz.smf(self.fuzz_motor.universe, 20, 50)
self.fuzz_position['poor'] = fuzz.zmf(self.fuzz_position.universe, -5,
-2)
self.fuzz_position['average'] = fuzz.trimf(self.fuzz_position.universe,
[-5, 0, 5])
self.fuzz_position['good'] = fuzz.smf(self.fuzz_position.universe, 2,
5)
self.fuzz_motor2['poor'] = fuzz.zmf(self.fuzz_motor2.universe, -50,
-20)
self.fuzz_motor2['average'] = fuzz.trimf(self.fuzz_motor2.universe,
[-50, 0, 50])
self.fuzz_motor2['good'] = fuzz.smf(self.fuzz_motor2.universe, 20, 50)
self.fuzz_vv2['poor'] = fuzz.zmf(self.fuzz_vv2.universe, -5, -2.5)
self.fuzz_vv2['average'] = fuzz.trimf(self.fuzz_vv2.universe,
[-5, 0, 5])
self.fuzz_vv2['good'] = fuzz.smf(self.fuzz_vv2.universe, 2.5, 5)
# self.fuzz_pend1['average'].view()
# self.fuzz_pend1_v['average'].view()
# self.fuzz_motor['average'].view()
# self.fuzz_position['average'].view()
# self.fuzz_vv2['average'].view()
# self.fuzz_motor2['average'].view()
self.rule1 = ctrl.Rule(
self.fuzz_pend1['poor'] & self.fuzz_pend1_v['poor'],
self.fuzz_motor['poor'])
self.rule2 = ctrl.Rule(
self.fuzz_pend1['poor'] & self.fuzz_pend1_v['mediocre'],
self.fuzz_motor['poor'])
self.rule3 = ctrl.Rule(
self.fuzz_pend1['poor'] & self.fuzz_pend1_v['average'],
self.fuzz_motor['poor'])
self.rule4 = ctrl.Rule(
self.fuzz_pend1['poor'] & self.fuzz_pend1_v['decent'],
self.fuzz_motor['poor'])
self.rule5 = ctrl.Rule(
self.fuzz_pend1['poor'] & self.fuzz_pend1_v['good'],
self.fuzz_motor['poor'])
self.rule6 = ctrl.Rule(
self.fuzz_pend1['mediocre'] & self.fuzz_pend1_v['poor'],
self.fuzz_motor['poor'])
self.rule7 = ctrl.Rule(
self.fuzz_pend1['mediocre'] & self.fuzz_pend1_v['mediocre'],
self.fuzz_motor['poor'])
self.rule8 = ctrl.Rule(
self.fuzz_pend1['mediocre'] & self.fuzz_pend1_v['average'],
self.fuzz_motor['poor'])
self.rule9 = ctrl.Rule(
self.fuzz_pend1['mediocre'] & self.fuzz_pend1_v['decent'],
self.fuzz_motor['average'])
self.rule10 = ctrl.Rule(
self.fuzz_pend1['mediocre'] & self.fuzz_pend1_v['good'],
self.fuzz_motor['average'])
self.rule11 = ctrl.Rule(
self.fuzz_pend1['average'] & self.fuzz_pend1_v['poor'],
self.fuzz_motor['poor'])
self.rule12 = ctrl.Rule(
self.fuzz_pend1['average'] & self.fuzz_pend1_v['mediocre'],
self.fuzz_motor['poor'])
self.rule13 = ctrl.Rule(
self.fuzz_pend1['average'] & self.fuzz_pend1_v['average'],
self.fuzz_motor['average'])
self.rule14 = ctrl.Rule(
self.fuzz_pend1['average'] & self.fuzz_pend1_v['decent'],
self.fuzz_motor['good'])
self.rule15 = ctrl.Rule(
self.fuzz_pend1['average'] & self.fuzz_pend1_v['good'],
self.fuzz_motor['good'])
self.rule16 = ctrl.Rule(
self.fuzz_pend1['decent'] & self.fuzz_pend1_v['poor'],
self.fuzz_motor['average'])
self.rule17 = ctrl.Rule(
self.fuzz_pend1['decent'] & self.fuzz_pend1_v['mediocre'],
self.fuzz_motor['average'])
self.rule18 = ctrl.Rule(
self.fuzz_pend1['decent'] & self.fuzz_pend1_v['average'],
self.fuzz_motor['good'])
self.rule19 = ctrl.Rule(
self.fuzz_pend1['decent'] & self.fuzz_pend1_v['decent'],
self.fuzz_motor['good'])
self.rule20 = ctrl.Rule(
self.fuzz_pend1['decent'] & self.fuzz_pend1_v['good'],
self.fuzz_motor['good'])
self.rule21 = ctrl.Rule(
self.fuzz_pend1['good'] & self.fuzz_pend1_v['poor'],
self.fuzz_motor['good'])
self.rule22 = ctrl.Rule(
self.fuzz_pend1['good'] & self.fuzz_pend1_v['mediocre'],
self.fuzz_motor['good'])
self.rule23 = ctrl.Rule(
self.fuzz_pend1['good'] & self.fuzz_pend1_v['average'],
self.fuzz_motor['good'])
self.rule24 = ctrl.Rule(
self.fuzz_pend1['good'] & self.fuzz_pend1_v['decent'],
self.fuzz_motor['good'])
self.rule25 = ctrl.Rule(
self.fuzz_pend1['good'] & self.fuzz_pend1_v['good'],
self.fuzz_motor['good'])
self.pendulum_ctrl = ctrl.ControlSystem([
self.rule1, self.rule2, self.rule3, self.rule4, self.rule5,
self.rule6, self.rule7, self.rule8, self.rule9, self.rule10,
self.rule11, self.rule12, self.rule13, self.rule14, self.rule15,
self.rule16, self.rule17, self.rule18, self.rule19, self.rule20,
self.rule21, self.rule22, self.rule23, self.rule24, self.rule25
])
self.pendulum_fuzz = ctrl.ControlSystemSimulation(self.pendulum_ctrl)
self.rule110 = ctrl.Rule(
self.fuzz_vv2['poor'] & self.fuzz_position['poor'],
self.fuzz_motor2['good'])
self.rule111 = ctrl.Rule(
self.fuzz_vv2['poor'] & self.fuzz_position['average'],
self.fuzz_motor2['good'])
self.rule112 = ctrl.Rule(
self.fuzz_vv2['poor'] & self.fuzz_position['good'],
self.fuzz_motor2['average'])
self.rule113 = ctrl.Rule(
self.fuzz_vv2['average'] & self.fuzz_position['poor'],
self.fuzz_motor2['good'])
self.rule114 = ctrl.Rule(
self.fuzz_vv2['average'] & self.fuzz_position['average'],
self.fuzz_motor2['average'])
self.rule115 = ctrl.Rule(
self.fuzz_vv2['average'] & self.fuzz_position['good'],
self.fuzz_motor2['poor'])
self.rule116 = ctrl.Rule(
self.fuzz_vv2['good'] & self.fuzz_position['poor'],
self.fuzz_motor2['average'])
self.rule117 = ctrl.Rule(
self.fuzz_vv2['good'] & self.fuzz_position['average'],
self.fuzz_motor2['poor'])
self.rule118 = ctrl.Rule(
self.fuzz_vv2['good'] & self.fuzz_position['good'],
self.fuzz_motor2['poor'])
self.pendulum_ctrl2 = ctrl.ControlSystem([
self.rule110, self.rule111, self.rule112, self.rule113,
self.rule114, self.rule115, self.rule116, self.rule117,
self.rule118
])
self.pendulum_fuzz2 = ctrl.ControlSystemSimulation(self.pendulum_ctrl2)
def build_fuzzy_kpy(self):
fy_universe = np.linspace(self.low_input[1], self.high_input[1], self.num_input)
mx_universe = np.linspace(self.low_input[3], self.high_input[3], self.num_input)
fy = ctrl.Antecedent(fy_universe, 'fy')
mx = ctrl.Antecedent(mx_universe, 'mx')
input_names = ['nb', 'ns', 'ze', 'ps', 'pb']
fy.automf(names=input_names)
mx.automf(names=input_names)
kpy_universe = np.linspace(self.low_output[1], self.high_output[1], self.num_output)
kpy = ctrl.Consequent(kpy_universe, 'kpy')
output_names_3 = ['nb', 'ze', 'pb']
kpy.automf(names=output_names_3)
rule_kpy_0 = ctrl.Rule(antecedent=((fy['nb'] & mx['ns']) |
(fy['nb'] & mx['ze']) |
(fy['pb'] & mx['ze']) |
(fy['pb'] & mx['ps'])),
consequent=kpy['pb'], label='rule_kpy_pb')
rule_kpy_1 = ctrl.Rule(antecedent=((fy['ns'] & mx['ze']) |
(fy['ns'] & mx['ns']) |
(fy['ns'] & mx['nb']) |
(fy['ps'] & mx['ps']) |
(fy['ps'] & mx['pb']) |
(fy['ps'] & mx['ze']) |
(fy['nb'] & mx['nb']) |
(fy['pb'] & mx['pb'])),
consequent=kpy['ze'], label='rule_kpy_ze')
rule_kpy_2 = ctrl.Rule(antecedent=((fy['ze']) |
(fy['nb'] & mx['ps']) |
(fy['nb'] & mx['pb']) |
(fy['pb'] & mx['ns']) |
(fy['pb'] & mx['nb']) |
(fy['ns'] & mx['ps']) |
(fy['ns'] & mx['pb']) |
(fy['ps'] & mx['nb']) |
(fy['ps'] & mx['ns'])),
consequent=kpy['nb'], label='rule_kpy_nb')
system_kpy = ctrl.ControlSystem(rules=[rule_kpy_0, rule_kpy_1, rule_kpy_2])
sim_kpy = ctrl.ControlSystemSimulation(system_kpy, flush_after_run=self.num_mesh * self.num_mesh + 1)
"""kpx"""
# upsampled_x = self.unsampled[1]
# upsampled_y = self.unsampled[3]
# x, y = np.meshgrid(upsampled_x, upsampled_y)
# z = np.zeros_like(x)
#
# # Loop through the system 21*21 times to collect the control surface
# for i in range(21):
# for j in range(21):
# sim_kpy.input['fy'] = x[i, j]
# sim_kpy.input['mx'] = y[i, j]
# sim_kpy.compute()
# z[i, j] = sim_kpy.output['kpy']
#
# """ Plot the result in pretty 3D with alpha blending"""
# fig = plt.figure(figsize=(8, 8))
# ax = fig.add_subplot(111, projection='3d')
#
# surf = ax.plot_surface(x, y, z, rstride=1, cstride=1, cmap='viridis',
# linewidth=0.4, antialiased=True)
# plt.show()
return sim_kpy
si ve alto entonces alerta verde si vd ó td alto entonces alerta verde """ #reglas regla1 = ctrl.Rule(lete['alto'], alerta['naranja']) regla2 = ctrl.Rule(leve['alto'], alerta['naranja']) regla3 = ctrl.Rule(le['alto'], alerta['verde']) regla4 = ctrl.Rule(te['alto'], alerta['amarillo']) regla5 = ctrl.Rule(ve['alto'], alerta['verde']) regla6 = ctrl.Rule(vd['alto'] | td['alto'], alerta['verde']) # Cria um sistema de controle e uma simulação alerta_ctrl = ctrl.ControlSystem([regla1, regla2, regla3, regla4, regla5, regla6]) alerta_sim = ctrl.ControlSystemSimulation(alerta_ctrl) """ # Entrada test alerta_sim.input['lete'] = 10 alerta_sim.input['leve'] = 15 alerta_sim.input['le'] = 2 alerta_sim.input['te'] = 20 alerta_sim.input['ve'] = 25 alerta_sim.input['vd'] = 4 alerta_sim.input['td'] = 30 # Calcula alerta_sim.compute() alerta_sim.output alerta.view(sim=alerta_sim)
def brake_intention(brake_pedal, brake_drt):
brake = ctrl.Antecedent(np.linspace(0, 1, 81), 'brake')
brake_derivative = ctrl.Antecedent(np.linspace(-1, 1, 5121),
'derivative of brake')
driver_intention = ctrl.Consequent(np.linspace(-1, 0, 81),
'driver intention')
# Membership functions
# TODO: search papers to check membership functions
brake['S'] = fuzz.trapmf(brake.universe, [0, 0, 0.05, 0.1])
brake['RS'] = fuzz.trimf(brake.universe, [0, 0.075, 0.15])
brake['M'] = fuzz.trimf(brake.universe, [0.1, 0.15, 0.2])
brake['RB'] = fuzz.trimf(brake.universe, [0.15, 0.225, 0.3])
brake['B'] = fuzz.trapmf(brake.universe, [0.2, 0.3, 1, 1])
brake_derivative['NB'] = fuzz.trapmf(brake_derivative.universe,
[-1, -1, -0.14, -0.08])
brake_derivative['NS'] = fuzz.trimf(brake_derivative.universe,
[-0.12, -0.05, 0.02])
brake_derivative['S'] = fuzz.trimf(brake_derivative.universe,
[-0.02, 0.02, 0.06])
brake_derivative['M'] = fuzz.trimf(brake_derivative.universe,
[0.06, 0.09, 0.12])
brake_derivative['B'] = fuzz.trapmf(brake_derivative.universe,
[0.1, 0.14, 1, 1])
driver_intention['NL'] = fuzz.trapmf(driver_intention.universe,
[-1, -1, -0.9, -0.85])
driver_intention['NS'] = fuzz.trimf(driver_intention.universe,
[-0.9, -0.75, -0.6])
driver_intention['ZE'] = fuzz.trimf(driver_intention.universe,
[-0.7, -0.55, -0.4])
driver_intention['PS'] = fuzz.trimf(driver_intention.universe,
[-0.5, -0.35, -0.2])
driver_intention['PL'] = fuzz.trapmf(driver_intention.universe,
[-0.3, -0.2, 0, 0])
# brake.view()
# brake_derivative.view()
# driver_intention.view()
# Define rule base
rule1 = ctrl.Rule(brake['S'] & brake_derivative['NB'],
driver_intention['PL'])
rule2 = ctrl.Rule(brake['S'] & brake_derivative['NS'],
driver_intention['PL'])
rule3 = ctrl.Rule(brake['S'] & brake_derivative['S'],
driver_intention['PS'])
rule4 = ctrl.Rule(brake['S'] & brake_derivative['M'],
driver_intention['PS'])
rule5 = ctrl.Rule(brake['S'] & brake_derivative['B'],
driver_intention['ZE'])
rule6 = ctrl.Rule(brake['RS'] & brake_derivative['NB'],
driver_intention['PL'])
rule7 = ctrl.Rule(brake['RS'] & brake_derivative['NS'],
driver_intention['PS'])
rule8 = ctrl.Rule(brake['RS'] & brake_derivative['S'],
driver_intention['PS'])
rule9 = ctrl.Rule(brake['RS'] & brake_derivative['M'],
driver_intention['ZE'])
rule10 = ctrl.Rule(brake['RS'] & brake_derivative['B'],
driver_intention['ZE'])
rule11 = ctrl.Rule(brake['M'] & brake_derivative['NB'],
driver_intention['PS'])
rule12 = ctrl.Rule(brake['M'] & brake_derivative['NS'],
driver_intention['PS'])
rule13 = ctrl.Rule(brake['M'] & brake_derivative['S'],
driver_intention['ZE'])
rule14 = ctrl.Rule(brake['M'] & brake_derivative['M'],
driver_intention['ZE'])
rule15 = ctrl.Rule(brake['M'] & brake_derivative['B'],
driver_intention['NS'])
rule16 = ctrl.Rule(brake['RB'] & brake_derivative['NS'],
driver_intention['PS'])
rule17 = ctrl.Rule(brake['RB'] & brake_derivative['S'],
driver_intention['ZE'])
rule18 = ctrl.Rule(brake['RB'] & brake_derivative['S'],
driver_intention['ZE'])
rule19 = ctrl.Rule(brake['RB'] & brake_derivative['M'],
driver_intention['NS'])
rule20 = ctrl.Rule(brake['RB'] & brake_derivative['B'],
driver_intention['NL'])
rule21 = ctrl.Rule(brake['B'] & brake_derivative['NB'],
driver_intention['ZE'])
rule22 = ctrl.Rule(brake['B'] & brake_derivative['NS'],
driver_intention['ZE'])
rule23 = ctrl.Rule(brake['B'] & brake_derivative['S'],
driver_intention['NS'])
rule24 = ctrl.Rule(brake['B'] & brake_derivative['M'],
driver_intention['NL'])
rule25 = ctrl.Rule(brake['B'] & brake_derivative['B'],
driver_intention['NL'])
# rule1.view()
# Create control systems
driver_intention_ctrl = ctrl.ControlSystem([
rule1, rule2, rule3, rule4, rule5, rule6, rule7, rule8, rule9, rule10,
rule11, rule12, rule12, rule13, rule14, rule15, rule16, rule16, rule17,
rule18, rule19, rule20, rule21, rule22, rule23, rule24, rule25
])
driver_intention_fc = ctrl.ControlSystemSimulation(driver_intention_ctrl)
driver_intention_fc.input['brake'] = brake_pedal
driver_intention_fc.input['derivative of brake'] = brake_drt
driver_intention_fc.compute()
# print(driver_intention_fc.output['driver intention'])
# driver_intention.view(sim=driver_intention_fc)
return driver_intention_fc.output['driver intention']
rule18 = ctrl.Rule(v0['average'] & mew['mediocre'], xf['very close'])
rule19 = ctrl.Rule(v0['decent'] & mew['mediocre'], xf['close'])
rule20 = ctrl.Rule(v0['good'] & mew['mediocre'], xf['close'])
#Reglas para coeficientes bajos
rule21 = ctrl.Rule(v0['poor'] & mew['poor'], xf['very close'])
rule22 = ctrl.Rule(v0['mediocre'] & mew['poor'], xf['close'])
rule23 = ctrl.Rule(v0['average'] & mew['poor'], xf['far'])
rule24 = ctrl.Rule(v0['decent'] & mew['poor'], xf['very far'])
rule25 = ctrl.Rule(v0['good'] & mew['poor'], xf['super far'])
#Se juntan las reglas en el sistema y se simula
xf_control = ctrl.ControlSystem([
rule1, rule2, rule3, rule4, rule5, rule7, rule8, rule9, rule10, rule11,
rule12, rule13, rule14, rule15, rule16, rule17, rule18, rule19, rule20,
rule21, rule22, rule23, rule24, rule25
])
distance = ctrl.ControlSystemSimulation(xf_control)
#Generamos 3 figuras para graficar
fig = plt.figure()
ax1 = fig.add_subplot(131)
ax1.set_ylabel("Posición (μ = 0.1)")
ax1.set_xlabel("Velocidad Inicial")
ax2 = fig.add_subplot(132)
ax2.title.set_text("Posición final esperada (azul) vs Predicción (naranja)")
ax2.set_ylabel("Posición Final (μ = 0.2)")
ax2.set_xlabel("Velocidad Inicial")
ax3 = fig.add_subplot(133)
ax3.set_ylabel("Posición (μ = 0.3)")
ax3.set_xlabel("Velocidad Inicial")
#Comparamos distancias reales con los del sistema con μ = 0.1
v0_in = 1
distance.view()
angle.view()
velocity.view()
rules = [
ctrl.Rule(distance['good'], velocity['good']),
ctrl.Rule(distance['average'] & angle['poor'], velocity['good']),
ctrl.Rule(distance['average'] & angle['average'], velocity['average']),
ctrl.Rule(distance['average'] & angle['good'], velocity['good']),
ctrl.Rule(distance['poor'] & angle['poor'], velocity['average']),
ctrl.Rule(distance['poor'] & angle['average'], velocity['poor']),
ctrl.Rule(distance['poor'] & angle['good'], velocity['average']),
]
velocity_ctrl = ctrl.ControlSystem(rules)
velocity_sim = ctrl.ControlSystemSimulation(velocity_ctrl)
def test(data):
d = data["d"]
a = data["a"]
v1 = data["v1"]
# Comparing fuzzy predictions with real values (calculated from equation) for 'd' and 'a' only
err_sum = 0
for d_value, a_value, v1_value in zip(d, a, v1):
a_value_normalized = round(a_value / (3.1415 / 2) *
90) # convert radians to angle
velocity_sim.input['distance'] = d_value
velocity_sim.input['angle'] = a_value_normalized
velocity_sim.compute()
def __init__(self):
self.sf = 255
self.write_decision(init)
self.stop_f = 0
self.eeg_bands = {
'Delta': (2, 4),
'Theta': (4, 8),
'Alpha': (8, 12),
'Beta': (12, 30),
'Gamma': (30, 45)
}
self.band_name = ['Delta', 'Theta', 'Alpha', 'Beta', 'Gamma']
# self.eeg_bands = {'Delta': (4,6), 'Theta': (6, 8), 'Alpha': (8, 10), 'Beta': (10, 12), 'Gamma': (12, 14)}
# self.band_name = ['Delta', 'Theta', 'Alpha', 'Beta', 'Gamma']
self.ch1_bandpower = [0.1, 0.1, 0.1, 0.1, 1.0]
self.ch2_bandpower = [0.1, 0.1, 0.1, 0.1, 1.0]
self.ch1_bandamp = [1000, 2000, 2000, 2000, 4000]
self.ch2_bandamp = [1000, 2000, 2000, 2000, 4000]
self.fft_vals = np.array([])
self.fft_freq = np.array([])
self.ch1_power_x = np.arange(len(self.band_name))
self.ch2_power_x = np.arange(len(self.band_name))
self.ch1_plot = np.array([])
self.ch1_x_ax = np.array([])
self.ch2_plot = np.array([])
self.ch2_x_ax = np.array([])
self.ch1_detrend = np.array([])
self.ch2_detrend = np.array([])
self.ch1_filt = np.array([])
self.ch2_filt = np.array([])
self.ch1_plot_delta = np.array([])
self.ch1_plot_theta = np.array([])
self.ch1_plot_alpha = np.array([])
self.ch1_plot_beta = np.array([])
self.ch1_plot_gamma = np.array([])
self.ch2_plot_delta = np.array([])
self.ch2_plot_theta = np.array([])
self.ch2_plot_alpha = np.array([])
self.ch2_plot_beta = np.array([])
self.ch2_plot_gamma = np.array([])
self.ch1_beta_peak = np.array([])
self.ch1_beta_peak_x = np.array([])
self.ch2_beta_peak = np.array([])
self.ch2_beta_peak_x = np.array([])
self.ch1_theta_peak = np.array([])
self.ch1_theta_peak_x = np.array([])
self.ch2_theta_peak = np.array([])
self.ch2_theta_peak_x = np.array([])
self.plot_time = 0
self.ch1_beta_count = 0
self.ch2_beta_count = 0
self.ch1_theta_count = 0
self.ch2_theta_count = 0
self.forward_f = 0
self.forward_f2 = 0
self.stop_f = 0
self.stop_f2 = 0
self.c1_theta = ctrl.Antecedent(np.arange(0, 7, 1), 'ch1_theta')
self.c2_theta = ctrl.Antecedent(np.arange(0, 7, 1), 'ch2_theta')
self.c1_beta = ctrl.Antecedent(np.arange(0, 10, 1), 'ch1_beta')
self.c2_beta = ctrl.Antecedent(np.arange(0, 10, 1), 'ch2_beta')
self.result1 = ctrl.Consequent(np.arange(0, 1, 0.1), 'blink_one_eye')
self.result2 = ctrl.Consequent(np.arange(0, 1, 0.1), 'blink_two_eye')
self.result3 = ctrl.Consequent(np.arange(0, 1, 0.1), 'raise_eyebrow')
self.result4 = ctrl.Consequent(np.arange(0, 1, 0.1), 'look left')
# self.c1_theta.automf(3)
# self.c2_theta.automf(3)
# self.c1_beta.automf(3)
# self.c2_beta.automf(3)
self.c1_theta['poor'] = fuzz.trimf(self.c1_theta.universe, [0, 0, 3])
self.c1_theta['average'] = fuzz.trimf(self.c1_theta.universe,
[0, 3, 5])
self.c1_theta['good'] = fuzz.trimf(self.c1_theta.universe, [3, 7, 7])
self.c2_theta['poor'] = fuzz.trimf(self.c2_theta.universe, [0, 0, 3])
self.c2_theta['average'] = fuzz.trimf(self.c2_theta.universe,
[0, 3, 5])
self.c2_theta['good'] = fuzz.trimf(self.c2_theta.universe, [3, 7, 7])
self.c1_beta['poor'] = fuzz.trimf(self.c1_beta.universe, [0, 0, 3])
self.c1_beta['average'] = fuzz.trimf(self.c1_beta.universe, [0, 3, 8])
self.c1_beta['good'] = fuzz.trimf(self.c1_beta.universe, [8, 10, 10])
self.c2_beta['poor'] = fuzz.trimf(self.c2_beta.universe, [0, 0, 3])
self.c2_beta['average'] = fuzz.trimf(self.c2_beta.universe, [0, 3, 8])
self.c2_beta['good'] = fuzz.trimf(self.c2_beta.universe, [8, 10, 10])
self.result1.automf(3)
self.result2.automf(3)
self.result3.automf(3)
self.result4.automf(3)
self.rule1 = ctrl.Rule((self.c2_beta['good'] | self.c2_theta['good'])
& self.c1_theta['poor'] & self.c1_beta['poor'],
self.result1['good'])
self.rule2 = ctrl.Rule(self.c2_beta['poor'] | self.c2_theta['poor'],
self.result1['poor'])
self.rule3 = ctrl.Rule(
self.c2_beta['average'] & self.c2_theta['average'],
self.result1['poor'])
self.rule4 = ctrl.Rule((self.c2_beta['good'] | self.c2_theta['good'])
& self.c1_theta['good'], self.result1['poor'])
self.rule5 = ctrl.Rule((self.c1_theta['good'] | self.c2_theta['good']),
self.result2['good'])
self.rule6 = ctrl.Rule(self.c1_theta['poor'] | self.c2_theta['poor'],
self.result2['poor'])
self.rule7 = ctrl.Rule(
self.c1_theta['average'] | self.c2_theta['average'],
self.result2['average'])
self.rule8 = ctrl.Rule(
self.c1_theta['average'] & self.c2_theta['average'],
self.result2['good'])
self.rule9 = ctrl.Rule(
(self.c2_beta['average'] & self.c1_beta['average']),
self.result3['good'])
self.rule10 = ctrl.Rule(
self.c2_beta['average'] | self.c1_beta['average'],
self.result3['average'])
self.rule11 = ctrl.Rule((self.c2_beta['good'] | self.c1_beta['good']),
self.result3['good'])
self.rule12 = ctrl.Rule(self.c2_beta['poor'] | self.c1_beta['poor'],
self.result3['poor'])
self.rule13 = ctrl.Rule(
self.c1_theta['average'] & self.c2_theta['average'],
self.result4['good'])
self.rule14 = ctrl.Rule(self.c1_theta['good'] | self.c2_theta['good'],
self.result4['poor'])
self.rule15 = ctrl.Rule(self.c1_theta['poor'] & self.c2_theta['poor'],
self.result4['poor'])
# self.rule13 = ctrl.Rule((self.c2_beta['good'] | self.c1_beta['good']), self.result3['average'])
# self.rule5 = ctrl.Rule(self.c1_beta['good'] & self.c2_beta['good'] & self.c1_theta['poor'] & self.c2_theta['poor'], self.result3['good'])
# self.rule6 = ctrl.Rule(self.c1_beta['poor'] & self.c2_beta['poor'], self.result2['poor'])
# self.rule7 = ctrl.Rule(self.c1_beta['poor'] & self.c2_beta['poor'] & self.c1_theta['poor'] & self.c2_theta['poor'], self.result3['good'])
self.drone_control = ctrl.ControlSystem([
self.rule1, self.rule2, self.rule3, self.rule4, self.rule5,
self.rule6, self.rule7, self.rule8, self.rule9, self.rule10,
self.rule11, self.rule12, self.rule13, self.rule14, self.rule15
])
self.drone = ctrl.ControlSystemSimulation(self.drone_control)
pyplot.ion()
self.fig = pyplot.figure()
self.ch1_fig = self.fig.add_subplot(221)
self.ch1_beta_peak_line, = self.ch1_fig.plot(self.ch1_beta_peak_x,
self.ch1_beta_peak,
c='r',
marker='x')
self.ch1_theta_peak_line, = self.ch1_fig.plot(self.ch1_theta_peak_x,
self.ch2_theta_peak,
c='r',
marker='o')
# self.ch1_line, = self.ch1_fig.plot(self.ch1_x'_ax, self.ch1_plot)
# self.ch1_delta_line, = self.ch1_fig.plot(self.ch1_x_ax, self.ch1_plot_delta, color="red")
self.ch1_theta_line, = self.ch1_fig.plot(self.ch1_x_ax,
self.ch1_plot_theta,
color='green')
self.ch1_alpha_line, = self.ch1_fig.plot(self.ch1_x_ax,
self.ch1_plot_alpha,
color='yellow')
self.ch1_beta_line, = self.ch1_fig.plot(self.ch1_x_ax,
self.ch1_plot_beta,
color='purple')
self.ch1_gamma_line, = self.ch1_fig.plot(self.ch1_x_ax,
self.ch1_plot_gamma,
color='orange')
pyplot.title("CH1 Raw Data")
pyplot.legend(['beta_p', 'theta_p', 'theta', 'alpha', 'beta', 'gamma'],
loc='upper left')
self.ch2_fig = self.fig.add_subplot(222)
self.ch2_beta_peak_line, = self.ch2_fig.plot(self.ch2_x_ax,
self.ch2_beta_peak,
c='r',
marker='x')
self.ch2_theta_peak_line, = self.ch2_fig.plot(self.ch2_x_ax,
self.ch2_theta_peak,
c='r',
marker='o')
# self.ch2_line, = self.ch2_fig.plot(self.ch2_x_ax, self.ch2_plot)
self.ch2_theta_line, = self.ch2_fig.plot(self.ch2_x_ax,
self.ch2_plot_theta,
color='green')
self.ch2_alpha_line, = self.ch2_fig.plot(self.ch2_x_ax,
self.ch2_plot_alpha,
color='yellow')
self.ch2_beta_line, = self.ch2_fig.plot(self.ch2_x_ax,
self.ch2_plot_beta,
color='purple')
self.ch2_gamma_line, = self.ch2_fig.plot(self.ch2_x_ax,
self.ch2_plot_gamma,
color='orange')
pyplot.legend(['beta_p', 'theta_p', 'theta', 'alpha', 'beta', 'gamma'],
loc='upper left')
pyplot.title("CH2 Raw Data")
# self.ch1_d_fig = self.fig.add_subplot(323)
# pyplot.title("CH1 Power Spectral")
# self.ch2_d_fig = self.fig.add_subplot(324)
# pyplot.title("CH2 Power Spectral")
self.ch1_bar_fig = self.fig.add_subplot(223)
pyplot.title("CH1 BandPower")
pyplot.xticks(self.ch1_power_x, self.band_name)
# self.ch2_bar_fig = self.fig.add_subplot(224)
# pyplot.title("CH2 BandPower")
# pyplot.xticks(self.ch1_power_x, self.band_name)
#
# self.ch1_bar2_fig = self.fig.add_subplot(425)
# pyplot.title("CH1 BandAmplitude")
# pyplot.xticks(self.ch1_power_x, self.band_name)
#
# self.ch2_bar2_fig = self.fig.add_subplot(426)
# pyplot.title("CH2 BandAmplitude")
# pyplot.xticks(self.ch1_power_x, self.band_name)
# self.ch1_d_line, = self.ch1_d_fig.plot(self.ch1_x_ax, self.ch1_detrend)
# self.ch2_d_line, = self.ch2_d_fig.plot(self.ch2_x_ax, self.ch2_detrend)
#
self.ch1_rect = self.ch1_bar_fig.bar(self.ch1_power_x,
self.ch1_bandpower)
# self.ch2_rect = self.ch2_bar_fig.bar(self.ch2_power_x, self.ch2_bandpower)
#
# self.ch1_rect2 = self.ch1_bar2_fig.bar(self.ch1_power_x, self.ch1_bandamp)
# self.ch2_rect2 = self.ch2_bar2_fig.bar(self.ch2_power_x, self.ch2_bandamp)
pyplot.show()
# * rule2: "If service is average, then tip will be average # * rule3: "If service is good OR food is good, then tip will be good rule1 = ctrl.Rule(quality['poor'] | service['poor'], tip['poor']) rule2 = ctrl.Rule(service['average'], tip['average']) rule3 = ctrl.Rule(service['good'] | quality['good'], tip['good']) #rule1.view() # Create a new ControlSystem with these rules added # Note: it is possible to create an empty ControlSystem() and build it up interactively. tipping_ctrl = ctrl.ControlSystem([rule1, rule2, rule3]) # View the whole system tipping_ctrl.view() tipping = ctrl.ControlSystemSimulation(tipping_ctrl) # Pass inputs to the ControlSystem using Antecedent labels with Pythonic API # Note: if you like passing many inputs all at once, use .inputs(dict_of_data) tipping.input['quality'] = 6.5 tipping.input['service'] = 9.8 # Crunch the numbers tipping.compute() # Output available as a dict, for arbitrary number of consequents #print (tipping.output['tip']) tip.view(sim=tipping) # Viewing the Consequent again after computation shows the calculated system #tip.view(sim=tipping)
def buildFuzzySystem(showDescription = False):
"""
===========================================================================
Build Fuzzy Sistem for variable: memory
===========================================================================
**Args**:
showDescription: (boolean)
**Returns**:
None
"""
#==========================================================================
# Set labels of inputs and outputs
#==========================================================================
var_in1_label = 'diskusage'
var_out_label = 'out'
logger.info("buildFuzzySystem:" + var_in1_label)
#==========================================================================
# Set numerical range of inputs and outputs
#==========================================================================
in1_max = 100.0
var_in1_universe = np.arange(0, in1_max, in1_max/1000.0)
var_out_universe = np.arange(0, 1, 0.01)
#==========================================================================
# Set inputs(Antecedent) and outputs (Consequent)
#==========================================================================
var_in1 = ctrl.Antecedent(var_in1_universe, var_in1_label)
var_out = ctrl.Consequent(var_out_universe, var_out_label)
#==========================================================================
# Set membership functions of fuzzy set
#==========================================================================
var_in1.automf(number=3, variable_type='quant')
var_in1['average'] = fuzz.trapmf(var_in1.universe, [in1_max*0.2, in1_max*0.4, in1_max*0.9, in1_max*0.98])
var_in1['high'] = fuzz.smf(var_in1.universe, in1_max*0.9, in1_max*0.98)
var_out['low'] = fuzz.zmf(var_out.universe, 0.4, 0.8)
var_out['high'] = fuzz.smf(var_out.universe, 0.7, 0.9)
#==========================================================================
# Set fuzzy rules
#==========================================================================
rule1 = ctrl.Rule(var_in1['high'], var_out['high'])
rule2 = ctrl.Rule(var_in1['low'] | var_in1['average'] , var_out['low'])
#==========================================================================
# Build fuzzy control system and simulation
#==========================================================================
var_ctrl = ctrl.ControlSystem([rule1, rule2])
var_fuzzysim = ctrl.ControlSystemSimulation(var_ctrl)
#==========================================================================
# Set fuzzy rules
#==========================================================================
if showDescription:
fig = plt.figure(figsize=(12, 12))
plt.subplot(3, 1, 1)
plt.title('Input: '+var_in1_label)
plt.plot(var_in1_universe, var_in1['low'].mf, label='low')
plt.plot(var_in1_universe, var_in1['average'].mf, label='average')
plt.plot(var_in1_universe, var_in1['high'].mf, label='high')
plt.legend()
plt.subplot(3, 1, 2)
plt.title('Output: '+var_out_label)
plt.plot(var_out_universe, var_out['low'].mf, label='low')
plt.plot(var_out_universe, var_out['high'].mf, label='high')
plt.legend()
var_fuzzysim.input[var_in1_label] = var_in1_universe
var_fuzzysim.compute()
y = var_fuzzysim.output[var_out_label]
plt.subplot(3, 1, 3)
plt.plot(var_in1_universe, y, label='Fuzzy transform of '+var_in1_label)
#plt.show()
plt.savefig('/tmp/fuzzy_'+var_in1_label+'.png')
return var_fuzzysim
