# 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