def defuzz(self): """Derive crisp value based on membership of adjective(s).""" if not self.sim._array_inputs: ups_universe, output_mf, cut_mfs = self.find_memberships() if len(cut_mfs) == 0: raise ValueError( "No terms have memberships. Make sure you " "have at least one rule connected to this " "variable and have run the rules calculation.") try: return defuzz(ups_universe, output_mf, self.var.defuzzify_method) except AssertionError: raise ValueError( "Crisp output cannot be calculated, likely " "because the system is too sparse. Check to " "make sure this set of input values will " "activate at least one connected Term in each " "Antecedent via the current set of Rules.") else: # Calculate using array-aware version, one cut at a time. output = np.zeros(self.sim._array_shape, dtype=np.float64) it = np.nditer(output, ['multi_index'], [['writeonly', 'allocate']]) for out in it: universe, mf = self.find_memberships_nd(it.multi_index) out[...] = defuzz(universe, mf, self.var.defuzzify_method) return output
def test_defuzz(): x = np.arange(21) - 10 gmf = fuzz.gaussmf(x, 0, 2) assert_allclose(0, fuzz.defuzz(x, gmf, 'centroid'), atol=1e-9) assert_allclose(0, fuzz.defuzz(x, gmf, 'bisector'), atol=1e-9) assert_allclose(0, fuzz.defuzz(x, gmf, 'mom')) assert_allclose(0, fuzz.defuzz(x, gmf, 'som')) assert_allclose(0, fuzz.defuzz(x, gmf, 'lom')) # Fuzzy plateau to differentiate mom, som, lom trapmf = fuzz.trapmf(x, [-1, 3, 7, 8]) assert_allclose(3, fuzz.defuzz(x, trapmf, 'som')) assert_allclose(5, fuzz.defuzz(x, trapmf, 'mom')) assert_allclose(7, fuzz.defuzz(x, trapmf, 'lom')) # Make sure som/lom work for all-negative universes: x_neg = x-20 assert_allclose(-17, fuzz.defuzz(x_neg, trapmf, 'som')) assert_allclose(-13, fuzz.defuzz(x_neg, trapmf, 'lom')) # Bad string argument assert_raises(ValueError, fuzz.defuzz, x, trapmf, 'bad string')
def speed_type(speedvalue, speedtype): if speedtype == "Fast": new_arg = fuzz.interp_universe(speedo, fast, speedvalue)[-1] tip_fast = np.fmin(fast, new_arg) try: res = fuzz.defuzz(speedo, tip_fast, 'centroid') except: return new_arg, 0 elif speedtype == "Slower": new_arg = fuzz.interp_universe(speedo, slower, speedvalue)[-1] tip_slower = np.fmin(slower, new_arg) try: res = fuzz.defuzz(speedo, tip_slower, 'centroid') except: return new_arg, 0 elif speedtype == "Slow": new_arg = fuzz.interp_universe(speedo, slow, speedvalue)[-1] tip_slow = np.fmin(slow, new_arg) try: res = fuzz.defuzz(speedo, tip_slow, 'centroid') except: return new_arg, 0 elif speedtype == "Stop": new_arg = fuzz.interp_universe(speedo, stop, speedvalue)[-1] tip_stop = np.fmin(stop, new_arg) try: res = fuzz.defuzz(speedo, tip_stop, 'centroid') except: return new_arg, 0 return new_arg, res
def defuzz(self): """Derive crisp value based on membership of adjective(s).""" if not self.sim._array_inputs: ups_universe, output_mf, cut_mfs = self.find_memberships() if len(cut_mfs) == 0: raise ValueError("No terms have memberships. Make sure you " "have at least one rule connected to this " "variable and have run the rules calculation.") try: return defuzz(ups_universe, output_mf, self.var.defuzzify_method) except AssertionError: raise ValueError("Crisp output cannot be calculated, likely " "because the system is too sparse. Check to " "make sure this set of input values will " "activate at least one connected Term in each " "Antecedent via the current set of Rules.") else: # Calculate using array-aware version, one cut at a time. output = np.zeros(self.sim._array_shape, dtype=np.float64) it = np.nditer(output, ['multi_index'], [['writeonly', 'allocate']]) for out in it: universe, mf = self.find_memberships_nd(it.multi_index) out[...] = defuzz(universe, mf, self.var.defuzzify_method) return output
def desfuzzy(universe, fuzzy_array): # Defuzzify this membership function five ways defuzz_centroid = fuzz.defuzz(universe, fuzzy_array, 'centroid') # Same as skfuzzy.centroid defuzz_bisector = fuzz.defuzz(universe, fuzzy_array, 'bisector') # Collect info for vertical lines labels = [ 'centroid', 'bisector', 'mean of maximum', 'min of maximum', 'max of maximum' ] xvals = [defuzz_centroid, defuzz_bisector] colors = ['r', 'b'] ymax = [fuzz.interp_membership(universe, fuzzy_array, i) for i in xvals] # Display and compare defuzzification results against membership function plt.figure(figsize=(8, 5)) plt.plot(universe, fuzzy_array, 'k') for xv, y, label, color in zip(xvals, ymax, labels, colors): plt.vlines(xv, 0, y, label=label, color=color) plt.ylabel('Fuzzy membership') plt.xlabel('Universe variable (arb)') plt.ylim(-0.1, 1.1) plt.legend(loc=2) plt.show()
def _setDefuzzMethod(self, m): rightMax = 'Right-Max' centroid = 'Centroid' # u - aggregated membership function values. if m == rightMax: self._defuzzMethod = lambda u: fz.defuzz(self._rotationAngleX, u, 'lom') elif m == centroid: self._defuzzMethod = lambda u: fz.defuzz(self._rotationAngleX, u, 'centroid') else: raise ValueError(f'Expected "{rightMax}" or "{centroid}"')
def interpret_data(agent): ball_angle = angle2D(agent.ball, agent.me) ball_distance = distance2D(agent.ball, agent.me) # Get distance to ball rule = [] throttle_activation = [] steer_activation = [] for i in range(0, agent.num_rules): if (agent.labels[i * 3 + 2].find('c') > 0): rule_a1 = fuzz.interp_membership(agent.universes[i * 3], agent.ruleset[i * 3], ball_distance) rule_a2 = fuzz.interp_membership(agent.universes[i * 3 + 1], agent.ruleset[i * 3 + 1], ball_angle) active_rule = np.fmax(rule_a1, rule_a2) rule_support = np.fmin(active_rule, agent.ruleset[i * 3 + 2]) throttle_activation.append(rule_support) else: rule_a1 = fuzz.interp_membership(agent.universes[i * 3], agent.ruleset[i * 3], ball_distance) rule_a2 = fuzz.interp_membership(agent.universes[i * 3 + 1], agent.ruleset[i * 3 + 1], ball_angle) active_rule = np.fmax(rule_a1, rule_a2) rule_support = np.fmin(active_rule, agent.ruleset[i * 3 + 2]) steer_activation.append(rule_support) agg_throttle = 0 agg_steer = 0 for i in range(0, len(throttle_activation) - 1): agg_throttle = np.fmax(throttle_activation[i], throttle_activation[i + 1]) for i in range(0, len(steer_activation) - 1): agg_steer = np.fmax(steer_activation[i], steer_activation[i + 1]) throttle = 0 steer = 0 if (any(agg_throttle) > 0): throttle = fuzz.defuzz(agent.fuzzy.throttle, agg_throttle, 'centroid') if (any(agg_steer) > 0): steer = fuzz.defuzz(agent.fuzzy.turn, agg_steer, 'centroid') #print(steer) return [throttle, steer]
def getFuzzyAcceleration(self, currentBatAngle, predictedBatAngle): dif = abs(currentBatAngle - predictedBatAngle) if (dif > 180): self.InputDistanceAngle = 360 - dif else: self.InputDistanceAngle = dif ''' self.thetaOne = abs(currentBatAngle-predictedBatAngle) self.thetaTwo = currentBatAngle + (360-predictedBatAngle) if(self.thetaOne < self.thetaTwo): self.InputDistanceAngle = self.thetaOne else: self.InputDistanceAngle = self.thetaTwo ''' self.InputDistanceAngle = int(self.InputDistanceAngle) #print "final angle to cover----",int(self.InputDistanceAngle) #print "buggy parth=============",self.R_combined[self.distance == self.InputDistanceAngle] self.OutputAcceleration = fuzz.defuzz( self.acceleration, self.R_combined[self.distance == self.InputDistanceAngle], 'centroid') #print "correspoinding acceleration",self.OutputAcceleration return self.OutputAcceleration #test code starts here '''
def fuzzy_system(generation_val, convergence_val): # just to ensure that value excceding 1 will be taken care by the code. if (convergence_val > 1): convergence_val = 0.99 x_generation = np.arange(0, 1500, 50) x_convergence = np.arange(0, 1, 0.1) x_recombinationRate = np.arange(0, 0.5, 0.1) # Generate fuzzy membership functions generation_lo = fuzz.trapmf(x_generation, [0, 0, 200, 300]) generation_md = fuzz.trimf(x_generation, [290, 550, 700]) generation_hi = fuzz.trapmf(x_generation, [690, 700, 1500, 1500]) convergence_lo = fuzz.trapmf(x_convergence, [0, 0, 0.2, 0.3]) convergence_md = fuzz.trapmf(x_convergence, [0.25, 0.4, 0.6, 0.75]) convergence_hi = fuzz.trapmf(x_convergence, [0.7, 0.8, 1, 1]) recom_lo = fuzz.trapmf(x_recombinationRate, [0, 0, 0.3, 0.4]) recom_md = fuzz.trapmf(x_recombinationRate, [0.35, 0.5, 0.5, 0.7]) recom_hi = fuzz.trapmf(x_recombinationRate, [0.7, 0.9, 1, 1]) generation_level_lo = fuzz.interp_membership(x_generation, generation_lo, generation_val) generation_level_md = fuzz.interp_membership(x_generation, generation_md, generation_val) generation_level_hi = fuzz.interp_membership(x_generation, generation_hi, generation_val) convergence_level_lo = fuzz.interp_membership(x_convergence, convergence_lo, convergence_val) convergence_level_md = fuzz.interp_membership(x_convergence, convergence_md, convergence_val) convergence_level_hi = fuzz.interp_membership(x_convergence, convergence_hi, convergence_val) # if generation level is high, recombination is low, do nothing to explore rate_activation_lo = np.fmin(generation_level_hi, recom_lo) # if generation is medium and convergence is low, recombination is medium: Try to boost the exploration active_rule1 = np.fmin(generation_level_md, fuzz.fuzzy_not(convergence_level_lo)) rate_activation_md = np.fmin(active_rule1, recom_md) # if generation is low or medium and convergence is high, give high recombination active_rule2 = np.fmax(fuzz.fuzzy_not(generation_level_hi), convergence_level_hi) rate_activation_hi = np.fmin(active_rule2, recom_hi) aggregated = np.fmax(rate_activation_lo, np.fmax(rate_activation_md, rate_activation_hi)) try: recom_rate = fuzz.defuzz(x_recombinationRate, aggregated, 'centroid') except: # if the member function is empty, just set the value to default low only recom_rate = 0.25 return recom_rate
def compute(tam, dst): # se difusan los valores. (tam_peq, tam_med, tam_grd) = pertenenciaTam(tam) (dst_crc, dst_ljs, dst_afr) = pertenenciaDst(dst) # se calcula la regla 1. prc_alt_grd = np.fmin(tam_grd, prc_alt) # se calcula la regla 2. prc_alt_crc = np.fmin(dst_crc, prc_alt) # se calcula la regla 3. prc_med_peqMedLjs = np.fmin(np.fmin(np.fmax(tam_peq, tam_med), dst_ljs), prc_med) # se calcula la regla 4. prc_baj_peqMedAfr = np.fmin(np.fmin(np.fmax(tam_peq, tam_med), dst_afr), prc_baj) # se combinan los resultados resultados_ = np.fmax( prc_alt_grd, np.fmax(prc_alt_crc, np.fmax(prc_med_peqMedLjs, prc_baj_peqMedAfr))) # se calcula el resultado "afilado" (usando el centroide de la forma) precio = fuzz.defuzz(x_prc, resultados_, 'centroid') return precio
def compute_tip_amout(qual_val, serv_val): qual_level_poor = fuzz.interp_membership(x_qual, qual_poor, qual_val) qual_level_amazing = fuzz.interp_membership(x_qual, qual_amazing, qual_val) serv_level_poor = fuzz.interp_membership(x_serv, serv_poor, serv_val) serv_level_acceptable = fuzz.interp_membership(x_serv, serv_acceptable, serv_val) serv_level_amazing = fuzz.interp_membership(x_serv, serv_amazing, serv_val) # Rule 1: IF service = poor OR food = poor THEN tip = low satisfaction_rule1 = np.fmax(qual_level_poor, serv_level_poor) tip_activation_low = np.fmin(satisfaction_rule1, tip_low) # Rule 2: IF service = acceptable THEN tip = medium tip_acitvation_medium = np.fmin(serv_level_acceptable, tip_medium) # Rule 3: IF service = amazing OR food = amazing THEN tip = high satisfaction_rule3 = np.fmax(qual_level_amazing, serv_level_amazing) tip_activation_high = np.fmin(satisfaction_rule3, tip_high) tip0 = np.zeros_like(x_tip) #각 규칙의 추론결과 결합 aggregated = np.fmax(tip_activation_low, np.fmax(tip_acitvation_medium, tip_activation_high)) # 비퍼지화 tip = fuzz.defuzz(x_tip, aggregated, 'centroid') return tip
def getFuzzyAcceleration(self,currentBatAngle,predictedBatAngle): dif = abs(currentBatAngle - predictedBatAngle) if(dif > 180): self.InputDistanceAngle = 360- dif else: self.InputDistanceAngle = dif ''' self.thetaOne = abs(currentBatAngle-predictedBatAngle) self.thetaTwo = currentBatAngle + (360-predictedBatAngle) if(self.thetaOne < self.thetaTwo): self.InputDistanceAngle = self.thetaOne else: self.InputDistanceAngle = self.thetaTwo ''' self.InputDistanceAngle = int(self.InputDistanceAngle) #print "final angle to cover----",int(self.InputDistanceAngle) #print "buggy parth=============",self.R_combined[self.distance == self.InputDistanceAngle] self.OutputAcceleration = fuzz.defuzz(self.acceleration,self.R_combined[self.distance == self.InputDistanceAngle], 'centroid') #print "correspoinding acceleration",self.OutputAcceleration return self.OutputAcceleration #test code starts here '''
def run(self): """ inputs[0] = ERROR AXIS ., so stores all possible error values inputs[1] = DEL_ERROR AXIS ., ,, inputs[2] = CONTROL_OUTPUT AXIS ., ,, ERROR DEL_ERROR CONTROL_OUTPUT m_value for crisp e and delta_e values b[0][0] -ve Medium || b[1][0] -ve Medium || b[2][0] -ve Medium .. f[0] | f_d[0] b[0][1] -ve small || b[1][1] -ve small || b[2][1] -ve small .. f[1] | f_d[1] b[0][2] zero || b[1][2] zero || b[2][2] zero .. f[2] | f_d[2] b[0][3] +ve small || b[1][3] +ve small || b[2][3] +ve small .. f[3] | f_d[3] b[0][4] +ve Medium || b[1][4] +ve Medium || b[2][4] +_ve Medium .. f[4] | f_d[4] f_mat is fuzzy fuzzy_matrix """ inputs = [ np.arange(var[0], var[1]+1, 1) for var in self.var_ranges] #step size = 1, third dimension of b matrix. As of now, an assumption. b = [] output = [0,0,0,0,0] out_final = [] for i in range(3) : b.append( [membership_f(self.mu[i], inputs[i], a) for a in self.d_mu[i] ]) # To visualize the membership func. call .. [ visualize_mf(b,inputs) ] f ,f_d = error_fuzzify(inputs, b, self.error, self.delta_e) f_mat = fuzzy_matrix(f,f_d) output = rule_base(b, f_mat, output) print 'output : ', output aggregated = np.fmax(output[0], np.fmax(output[1],np.fmax(output[2], np.fmax(output[3], output[4])))) out_final = fuzz.defuzz(inputs[2], aggregated, 'centroid') out_activation = fuzz.interp_membership(inputs[2], aggregated, out_final) # for plot visualize.visualize_mf(b,inputs,output, out_final, out_activation, aggregated) visualize.visualize_output(b, inputs, out_final, out_activation, aggregated) plt.show()
def fuzz_system(aftertaste, acidity): aftertaste_level_D = fuzz.interp_membership(x_aftertaste, aftertaste_D, aftertaste) aftertaste_level_O = fuzz.interp_membership(x_aftertaste, aftertaste_O, aftertaste) aftertaste_level_Y = fuzz.interp_membership(x_aftertaste, aftertaste_Y, aftertaste) # print("membership aftertaste_level_D: ", aftertaste_level_D) # print("membership aftertaste_level_O: ", aftertaste_level_O) # print("membership aftertaste_level_Y: ", aftertaste_level_Y) acidity_level_D = fuzz.interp_membership(x_acidity, acidity_D, acidity) acidity_level_O = fuzz.interp_membership(x_acidity, acidity_O, acidity) acidity_level_Y = fuzz.interp_membership(x_acidity, acidity_Y, acidity) # print("membership acidity_level_D: ", acidity_level_D) # print("membership acidity_level_O: ", acidity_level_O) # print("membership acidity_level_Y: ", acidity_level_Y) active_rule1 = np.fmin(acidity_level_D, aftertaste_level_D) active_rule2 = np.fmin(acidity_level_O, aftertaste_level_O) active_rule3 = np.fmin(acidity_level_Y, aftertaste_level_Y) flavor_activation_1 = np.fmin(active_rule1, flavor_D) flavor_activation_2 = np.fmin(active_rule2, flavor_O) flavor_activation_3 = np.fmin(active_rule3, flavor_Y) # flavor0 = np.zeros_like(x_flavor) aggregated = np.fmax (flavor_activation_1, np.fmax(flavor_activation_2, flavor_activation_3)) flavor_model = fuzz.defuzz(x_flavor, aggregated, 'centroid') # flavor_activation = wash_activation = fuzz.interp_membership(x_flavor, aggregated, flavor_model) return flavor_model
def update_reputation(self): eps = 0.1 t = np.ones(self.num_peers) * (1 / self.num_peers) t_next = np.ones(self.num_peers) * (1 / self.num_peers) dif = eps c = 0 while dif >= eps: for v in range(self.num_peers): t_v = 0 s = 0 for i in self.connected_peers[v]: s += t[i] if s != 0: x = 1 fuzzy_t_v = self.transactions[v][0][1] for tr in self.transactions[v][1:]: crisp = t[tr[0]] / s r = PeerTrustFuzzyEnv.fuzzy_mul(tr[1], crisp) fuzzy_t_v = PeerTrustFuzzyEnv.fuzzy_add(fuzzy_t_v, r) if self.fuzz_type == 1: pass elif self.fuzz_type == 2: fuzzy_t_v = PeerTrustFuzzyEnv.defuzz_2(fuzzy_t_v) else: raise NotImplementedError f = fuzzy_t_v, np.array([0, 1, 1, 0]) t_v = fuzz.defuzz(f[0], f[1], self.defuzz_method) t_next[v] = t_v d = t_next - t dif = np.linalg.norm(d) t = t_next c += 1 self.convergence.append(c) self.reputation = t_next
def calculate_target_speed(distance_to_go): distance, far, medium, close, v_close = set_distance_types() speed, fast, medium_fast, slow, stop = set_speed_types() # jeżeli daleko to szybko distance_level_far = fuzz.interp_membership(distance, far, distance_to_go) speed_activation_fast = np.fmin(distance_level_far, fast) # jeżeli średnio daleko to średnio szybko distance_level_medium = fuzz.interp_membership(distance, medium, distance_to_go) speed_activation_medium = np.fmin(distance_level_medium, medium_fast) # jeżeli blisko to wolno distance_level_close = fuzz.interp_membership(distance, close, distance_to_go) speed_activation_slow = np.fmin(distance_level_close, slow) # jeżeli bardzo blisko to stop distance_level_v_close = fuzz.interp_membership(distance, v_close, distance_to_go) speed_activation_stop = np.fmin(distance_level_v_close, stop) # agregacja aggregated = np.fmax( speed_activation_fast, np.fmax(speed_activation_medium, np.fmax(speed_activation_stop, speed_activation_slow))) # obliczenie zdyskretyzowanego wyniku return fuzz.defuzz(speed, aggregated, 'mom')
def compute_pi3k(egfr_value, erk_value, time_value, initial_values, mfs): """Rules --- if egfr is high and erk is low and time is high then pi3k is high if egfr is low or erk is high or time is low then pi3k is low""" a1_1 = mfs[0][1][initial_values[0] == egfr_value] #egfr_high[egfr == egfr_value] a1_2 = mfs[1][0][ initial_values[1] == erk_value] #erk_low[erk == erk_value] a1_3 = mfs[3][1][ initial_values[3] == time_value] if( a1_1.size == 0): a1_1 = mfs[0][1][ find_closest(initial_values[0], egfr_value)] if( a1_2.size == 0): a1_2 = mfs[1][0][ find_closest(initial_values[1], erk_value)] if( a1_3.size == 0): a1_3 = mfs[3][1][ find_closest(initial_values[3], time_value)] a1 = min(a1_1 , a1_2, a1_3) c1 = np.fmin( np.linspace(a1, a1, 100), mfs[2][1]) a2_1 = mfs[0][0][ initial_values[0] == egfr_value] #egfr_low[egfr == egfr_value] a2_2 = mfs[1][1][ initial_values[1] == erk_value] #erk_high[erk == erk_value] a2_3 = mfs[3][0][ initial_values[3] == time_value] if( a2_1.size == 0): a2_1 = mfs[0][0][ find_closest(initial_values[0], egfr_value)] if( a2_2.size == 0): a2_2 = mfs[1][1][ find_closest(initial_values[1], erk_value)] if( a2_3.size == 0): a2_3 = mfs[3][0][ find_closest(initial_values[3], time_value)] a2 = max(a2_1 , a2_2, a2_3) c2 = np.fmin( np.linspace(a2, a2, 100), mfs[2][0] ) c_com = np.fmax(c1, c2) return fuzz.defuzz(initial_values[2], c_com, 'centroid')
def defuzzify(output_ativations, classif): aggregated = 0 for out in output_ativations: aggregated = np.fmax(aggregated, out) value = fuzz.defuzz(classif, aggregated, 'mom') return value
def compute_akt(pi3k_value, time_value, initial_values, mfs): """Rules- If pi3k is high and time is high akt is high If pi3k is low or time is low then akt is low""" a1_1 = mfs[0][1][initial_values[0] == pi3k_value] a1_2 = mfs[2][1][initial_values[2] == time_value] if( a1_1.size == 0): a1_1 = mfs[0][1][ find_closest(initial_values[0], pi3k_value)] if( a1_2.size == 0): a1_2 = mfs[2][1][ find_closest(initial_values[2], time_value)] a1 = min(a1_1, a1_2) c1 = np.fmin( np.linspace(a1, a1, 100), mfs[1][1]) a2_1 = mfs[0][0][initial_values[0] == pi3k_value] a2_2 = mfs[2][0][initial_values[2] == time_value] if( a2_1.size == 0): a2_1 = mfs[0][0][ find_closest(initial_values[0], pi3k_value)] if( a2_2.size == 0): a2_2 = mfs[2][0][ find_closest(initial_values[2], time_value)] a2 = max(a2_1, a2_2) c2 = np.fmin( np.linspace(a2, a2, 100), mfs[1][0]) c_com = np.fmax(c1,c2) return fuzz.defuzz( initial_values[1], c_com, 'centroid')
def get_output(self, current_temp, target_temp, rate_of_change_per_minute): temp_err_in = self.temp_error_category(current_temp, target_temp, rate_of_change_per_minute) print "Temp Error", temp_err_in #What is the temperature doing? mf_temp_too_cold = temp_err_in['too_cold'] mf_temp_cold = temp_err_in['cold'] mf_temp_optimal = temp_err_in['optimal'] mf_temp_hot = temp_err_in['hot'] mf_temp_too_hot = temp_err_in['too_hot'] mf_cooling_quickly = temp_err_in['cooling_quickly'] #Then: when_too_cold = np.fmin(mf_temp_too_cold, self.ho_high) when_cold = np.fmin(mf_temp_cold, self.ho_low) when_optimal = np.fmin(mf_temp_optimal, self.co_off) when_hot = np.fmin(mf_temp_hot, self.co_low) when_too_hot = np.fmin(mf_temp_too_hot, self.co_high) #If the temperate is temp_hot AND cooling_quickly SET chiller off when_hot_and_cooling_quickly = np.fmin( np.fmin(mf_temp_hot, mf_cooling_quickly), self.co_off) aggregate_membership = np.fmax( when_hot_and_cooling_quickly, np.fmax( when_too_cold, np.fmax(when_cold, np.fmax(when_optimal, np.fmax(when_hot, when_too_hot))))) result = fuzz.defuzz(self.chill_out, aggregate_membership, 'centroid') return result
def defuzzify(self, method): """Compute crisp value from aggregated membership function. :param method: (str) name of defuzzification method """ assert (not self.value) assert (self.aggrmf is not None) self.value = fuzz.defuzz(self.x, self.aggrmf, method)
def fuzzy_inference(X, value1, value2, members, rules): mem1 = members[0] mem2 = members[1] mem3 = members[2] var1_low = fuzz.interp_membership(X[0], mem1[0], value1) var1_med = fuzz.interp_membership(X[0], mem1[1], value1) var1_high = fuzz.interp_membership(X[0], mem1[2], value1) var1 = [var1_low, var1_med, var1_high] var2_low = fuzz.interp_membership(X[1], mem2[0], value2) var2_med = fuzz.interp_membership(X[1], mem2[1], value2) var2_high = fuzz.interp_membership(X[1], mem2[2], value2) var2 = [var2_low, var2_med, var2_high] # Apply appropriate rule base activation_low, activation_med, activation_high, method = rule_base( var1, var2, mem3, rules) risk0 = np.zeros_like(X[0]) # Aggregation of the three output memership functions aggregated = np.fmax(activation_low, np.fmax(activation_med, activation_high)) # Defuzzify aggregation to crisp value result = fuzz.defuzz(X[2], aggregated, method) return result, risk0, aggregated
def get_output(self, current_temp, target_temp, rate_of_change_per_minute): temp_err_in = self.temp_error_category(current_temp, target_temp, rate_of_change_per_minute) print "Temp Error", temp_err_in #What is the temperature doing? mf_temp_too_cold = temp_err_in['too_cold'] mf_temp_cold = temp_err_in['cold'] mf_temp_optimal = temp_err_in['optimal'] mf_temp_hot = temp_err_in['hot'] mf_temp_too_hot = temp_err_in['too_hot'] mf_cooling_quickly = temp_err_in['cooling_quickly'] #Then: when_too_cold = np.fmin(mf_temp_too_cold, self.ho_high) when_cold = np.fmin(mf_temp_cold, self.ho_low) when_optimal = np.fmin(mf_temp_optimal, self.co_off) when_hot = np.fmin(mf_temp_hot, self.co_low) when_too_hot = np.fmin(mf_temp_too_hot, self.co_high) #If the temperate is temp_hot AND cooling_quickly SET chiller off when_hot_and_cooling_quickly = np.fmin(np.fmin(mf_temp_hot, mf_cooling_quickly), self.co_off) aggregate_membership = np.fmax(when_hot_and_cooling_quickly, np.fmax(when_too_cold, np.fmax(when_cold, np.fmax(when_optimal, np.fmax(when_hot, when_too_hot))))) result = fuzz.defuzz(self.chill_out, aggregate_membership, 'centroid') return result
def compute_erk_change(raf_value, time_value, initial_values, mfs): """Rules- If raf is high and time is high then positive_change_erk is high If raf is high1 and time is low then positive_change_erk is low If raf is low then positive_change_erk is low If raf is low and time is high then negative_change_erk is high If raf is low and time is low then negative_change_erk is low""" #Antecedent 1 f = interp1d(initial_values[0][0], mfs[0][1]) a1_1 = f(raf_value) #raf_high[raf == raf_value] f = interp1d(initial_values[2], mfs[2][1]) a1_2 = f(time_value) #time_high[time == time_value] a1 = min(a1_1, a1_2) c1 = np.fmin( a1, mfs[1][3]) #mfs[1][3] is positive_change_erk_high #Antecedent 2 f = interp1d(initial_values[0][0], mfs[0][6]) a2_1 = f(raf_value) f = interp1d(initial_values[2], mfs[2][0]) #time_low[time == time_value] a2_2 = f(time_value) a2 = min(a2_1, a2_2) c2 = np.fmin( a2, mfs[1][2]) #mfs[1][2] is positive_change_raf_low c_com_positive = np.fmax(c1,c2) f = interp1d(initial_values[0][0], mfs[0][0]) a3 = f(raf_value) c3 = np.fmin(a3, mfs[1][2]) c_com_positive = np.fmax(c_com_positive, c3) pos_change = fuzz.defuzz( initial_values[1][1], c_com_positive, 'centroid') #initial_values[1][1] is positive_change_erk ###Negative Change #Antecedent 3 '''f = interp1d(initial_values[0][0], mfs[0][0]) a3_1 = f(raf_value) #raf_low[raf == raf_value] a3_2 = a1_2 #time_high[time == time_value] a3 = min(a3_1,a3_2) c3 = np.fmin(a3, mfs[1][5]) #mfs[1][3] is negative_change_erk_high #Antecedent 4 a4_1 = a3_1 #raf_low[raf == raf_value] a4_2 = a2_2 #time_low[time == time_value] a4 = min(a4_1, a4_2) c4 = np.fmin(a4, mfs[1][4]) #mfs[1][4] is negative_change_erk_low c_com_negative = np.fmax(c3, c4) neg_change = fuzz.defuzz(initial_values[1][2], c_com_negative, 'centroid') #initial_values[1][2] is negative_change_erk''' #print pos_change, neg_change #print pos_change return pos_change
def test_bisector(): x = np.arange(6) mfx = fuzz.trimf(x, [0, 5, 5]) expected = 3.53553390593274 # Test both triangle code paths assert_allclose(expected, fuzz.defuzz(x, mfx, 'bisector')) assert_allclose(5 - expected, fuzz.defuzz(x, 1 - mfx, 'bisector')) # Test singleton input y = np.r_[2] mfy = np.r_[0.33] assert_allclose(y, fuzz.defuzz(y, mfy, 'bisector')) # Test rectangle code path mfx = fuzz.trapmf(x, [2, 2, 4, 4]) assert_allclose(3., fuzz.defuzz(x, mfx, 'bisector'))
def defuzz(self): """Derive crisp value based on membership of adjective(s).""" output_mf, cut_mfs = self.find_memberships() if len(cut_mfs) == 0: raise ValueError("No terms have memberships. Make sure you " "have at least one rule connected to this " "variable and have run the rules calculation.") return defuzz(self.var.universe, output_mf, self.var.defuzzify_method)
def fuzzifier(nota_qualidade, nota_servico): # Generate universe variables # * Quality and service on subjective ranges [0, 10] # * Tip has a range of [0, 25] in units of percentage points x_qual = np.arange(0, 11, 1) x_serv = np.arange(0, 11, 1) x_tip = np.arange(0, 26, 1) # Generate fuzzy membership functions qual_lo = fuzz.trimf(x_qual, [0, 0, 5]) qual_md = fuzz.trimf(x_qual, [0, 5, 10]) qual_hi = fuzz.trimf(x_qual, [5, 10, 10]) serv_lo = fuzz.trimf(x_serv, [0, 0, 5]) serv_md = fuzz.trimf(x_serv, [0, 5, 10]) serv_hi = fuzz.trimf(x_serv, [5, 10, 10]) tip_lo = fuzz.trimf(x_tip, [0, 0, 13]) tip_md = fuzz.trimf(x_tip, [0, 13, 25]) tip_hi = fuzz.trimf(x_tip, [13, 25, 25]) # We need the activation of our fuzzy membership functions at these values. # The exact values 6.5 and 9.8 do not exist on our universes... # This is what fuzz.interp_membership exists for! qual_level_lo = fuzz.interp_membership(x_qual, qual_lo, nota_qualidade) qual_level_md = fuzz.interp_membership(x_qual, qual_md, nota_qualidade) qual_level_hi = fuzz.interp_membership(x_qual, qual_hi, nota_qualidade) serv_level_lo = fuzz.interp_membership(x_serv, serv_lo, nota_servico) serv_level_md = fuzz.interp_membership(x_serv, serv_md, nota_servico) serv_level_hi = fuzz.interp_membership(x_serv, serv_hi, nota_servico) # Now we take our rules and apply them. Rule 1 concerns bad food OR service. # The OR operator means we take the maximum of these two. active_rule1 = np.fmax(qual_level_lo, serv_level_lo) # Now we apply this by clipping the top off the corresponding output # membership function with `np.fmin` tip_activation_lo = np.fmin(active_rule1, tip_lo) # removed entirely to 0 # For rule 2 we connect acceptable service to medium tipping tip_activation_md = np.fmin(serv_level_md, tip_md) # For rule 3 we connect high service OR high food with high tipping active_rule3 = np.fmax(qual_level_hi, serv_level_hi) tip_activation_hi = np.fmin(active_rule3, tip_hi) tip0 = np.zeros_like(x_tip) # Aggregate all three output membership functions together aggregated = np.fmax(tip_activation_lo, np.fmax(tip_activation_md, tip_activation_hi)) # Calculate defuzzified result # ----------THIS IS THE ANWSER------------------ tip = fuzz.defuzz(x_tip, aggregated, 'centroid') #------------------------------------------------ return tip
def compute_akt_change(pi3k_value, time_value, initial_values, mfs): """Rules- If pi3k is high and time is high then positive_change_akt is high If pi3k is high1 and time is low then positive_change_akt is low If pi3k is low then positive_change_pi3k is low If pi3k is low and time is high then negative_change_akt is high If pi3k is low and time is low then negative_change_akt is low""" ###Positive Change #Antecedent 1 f = interp1d(initial_values[0][0], mfs[0][1]) a1_1 = f(pi3k_value) #pi3k_high[pi3k == pi3k_value] f = interp1d(initial_values[2], mfs[2][1]) a1_2 = f(time_value) #time_high[time == time_value] a1 = min(a1_1, a1_2) c1 = np.fmin(a1, mfs[1][3]) #positive_change_akt is high #Antecedent 2 f = interp1d(initial_values[0][0], mfs[0][6]) a2_1 = f(pi3k_value) #pi3k_high[pi3k == pi3k_value] f = interp1d(initial_values[2], mfs[2][0]) a2_2 = f(time_value) #time_low[time == time_value] a2 = min(a2_1, a2_2) c2 = np.fmin( a2, mfs[1][2]) #positive_change_akt is low c_com_positive = np.fmax(c1,c2) f = interp1d(initial_values[0][0], mfs[0][0]) a3 = f(pi3k_value) c3 = np.fmin(a3, mfs[1][2]) c_com_positive = np.fmax(c_com_positive, c3) pos_change = fuzz.defuzz( initial_values[1][1], c_com_positive, 'centroid') #initial_values[1][1] is positive_change_akt ###Negative Change #Antecedent 3 '''f = interp1d(initial_values[0][0], mfs[0][0]) a3_1 = f(pi3k_value) #pi3k_low[pi3k == pi3k_value] a3_2 = a1_2 #time_high[time == time_value] a3 = min(a3_1, a3_2) c3 = np.fmin(a3, mfs[1][5]) #mfs[1][5] is negative_change_akt_high #Antecedent 4 a4_1 = a3_1 #pi3k_low[pi3k == pi3k_value] a4_2 = a2_2 #time_low[time == time_value] a4 = min(a4_1, a4_2) c4 = np.fmin(a4, mfs[1][4]) #mfs[1][4] is negative_change_akt_low c_com_negative = np.fmax(c3, c4) neg_change = fuzz.defuzz(initial_values[1][2], c_com_negative, 'centroid') #initial_values[1][2] is negative_change_akt''' return pos_change
def fuzzy_controller(self): x_vel = np.arange(-3.5, 2.1, 0.1) x_dis = np.arange(-80, 301, 1) x_acc = np.arange(-0.5, 0.6, 0.1) vel_slow = fuzz.trimf(x_vel, [-3.5, -3.5, 0]) vel_ok = fuzz.trimf(x_vel, [-3.5, 0, 2.0]) vel_fast = fuzz.trimf(x_vel, [0, 2.0, 2.1]) dis_close = fuzz.trimf(x_dis, [-80, -80, 0]) dis_ok = fuzz.trimf(x_dis, [-80, 0, 300]) dis_far = fuzz.trimf(x_dis, [0, 300, 300]) decelerate = fuzz.trimf(x_acc, [-1, -0.5, 0]) const = fuzz.trimf(x_acc, [-0.5, 0, 0.5]) accelerate = fuzz.trimf(x_acc, [0, 0.5, 0.5]) dis_level_close = fuzz.interp_membership(x_dis, dis_close, self.distance) dis_level_ok= fuzz.interp_membership(x_dis, dis_ok, self.distance) dis_level_far = fuzz.interp_membership(x_dis, dis_far, self.distance) vel_level_slow = fuzz.interp_membership(x_vel, vel_slow, self.delta_speed) vel_level_ok= fuzz.interp_membership(x_vel, vel_ok, self.delta_speed) vel_level_fast = fuzz.interp_membership(x_vel, vel_fast, self.delta_speed) rule1= np.fmin(dis_level_close, vel_level_slow) rule2= np.fmin(dis_level_close, vel_level_ok) rule3= np.fmin(dis_level_close, vel_level_fast) rule4= np.fmin(dis_level_ok, vel_level_slow) rule5= np.fmin(dis_level_ok, vel_level_ok) rule6= np.fmin(dis_level_ok, vel_level_fast) rule7= np.fmin(dis_level_far, vel_level_slow) rule8= np.fmin(dis_level_far, vel_level_ok) rule9= np.fmin(dis_level_far, vel_level_fast) decelerate_tot= max(rule1, rule2, rule3, rule6, rule9) const_tot= max(rule4, rule5, rule8) accelerate_tot = rule7 decelerate_activation= np.fmin(decelerate_tot, decelerate) const_activation= np.fmin(const_tot, const) accelerate_activation= np.fmin(accelerate_tot, accelerate) tip0 = np.zeros_like(x_acc) #################################################################### # Aggregate all three output membership functions together aggregated = np.fmax(decelerate_activation, np.fmax(const_activation, accelerate_activation)) #print (aggregated) #print("Fuzzy") # Calculate defuzzified result acc = fuzz.defuzz(x_acc, aggregated, 'centroid') self.acc_activation = fuzz.interp_membership(x_acc, aggregated, acc) # for plot
def defuzzy_fast(slice) : speed_range = np.arange(DOMAIN[0],DOMAIN[1],0.01) speed_high_fx = fuzz.trimf(speed_range,[SPEED[3],SPEED[4],SPEED[5]]) # print(speed_high_fx) speed_slice = np.fmin(slice,speed_high_fx) defuzzy_value = fuzz.defuzz(speed_range, speed_slice ,'centroid') return defuzzy_value
def calculate_erk(raf_mfs, erk_mfs, erk, raf_index): a1 = raf_mfs[0][raf_index] c1 = np.fmin(a1, erk_mfs[0]) a2 = raf_mfs[1][raf_index] c2 = np.fmin(a2, erk_mfs[1]) c_com = np.fmax(c1, c2) try: erk_val = fuzz.defuzz(erk, c_com, 'centroid') except AssertionError as e: erk_val = 0 return erk_val
def calculate_egfr(time_mfs, egfr_mfs, egfr, time_index): a1 = time_mfs[0][time_index] c1 = np.fmin(a1, egfr_mfs[0]) a2 = time_mfs[1][time_index] c2 = np.fmin(a2, egfr_mfs[1]) c_com = np.fmax(c1, c2) try: egfr_val = fuzz.defuzz(egfr, c_com, 'centroid') except AssertionError as e: egfr_val = 0 return egfr_val
def calaculate_akt(pi3k_mfs, akt_mfs, akt, pi3k_index): a1 = pi3k_mfs[0][pi3k_index] c1 = np.fmin(a1, akt_mfs[0]) a2 = pi3k_mfs[1][pi3k_index] c2 = np.fmin(a2, akt_mfs[1]) c_com = np.fmax(c1, c2) try: akt_val = fuzz.defuzz(akt, c_com, 'centroid') except AssertionError as e: akt_val = 0 return akt_val
def Centroid(self, domain: np.ndarray, aggregatedVariable: np.ndarray) -> float: if not isinstance(domain, np.ndarray): raise TypeError("domain") if not isinstance(aggregatedVariable, np.ndarray): raise TypeError("aggregatedVariable") if len(domain) != len(aggregatedVariable): raise ValueError("len(domain) != len(aggregatedVariable)") output = fuzz.defuzz(domain, aggregatedVariable, 'centroid') return output
def defuzzy(domain, newConsequentMFs): """Calculates the output value with the centroid based method. With the assumptions made, it will depens only on the degrees of activation and on the centroids of the original MFs.""" # Sum all the activated MFs in order to obtain one aggregated MF. aggregated = np.sum(newConsequentMFs, axis=0) # Find the output value output = fuzz.defuzz(domain, aggregated, 'centroid') return output
def next_action(t, b, s): """ ¦ t: target angle ¦ b: ball angle ¦ s: spin """ output = fuzz.defuzz(angle_dmn, output_function(t, b, s), 'centroid') outputrad = math.radians(output) cos_output = math.cos(outputrad) sin_output = math.sin(outputrad) return cos_output, sin_output
def run_system(self, input_list, output_key, TESTMODE=False): """ Runs the fuzzy system for a single output ------INPUTS------ input_list : dict dict of inputs {'input1':value, 'input2':value, ...} output_key : string string key of output to calculate TESTMODE : int testmode flag (1 = On) ------OUTPUTS------ """ self.TESTMODE = TESTMODE outs = [] for rule in self.rulebase: #iterate over rulebase if TESTMODE: print '------------------------------------------------------------------------' print 'TRANSLATING RULE: ', rule.rule_id #break apart antecedent and consequent if_i = rule.rule_list.index('IF') then_i = rule.rule_list.index('THEN') rule_ant = copy.deepcopy(rule.rule_list[if_i+1:then_i]) #get the rule antecedent rule_con = copy.deepcopy(rule.rule_list[then_i+1:len(rule.rule_list)+1])[0] #get the rule consequent if rule_con[0] == output_key: #only follow rule if it applies to given output fs = self.rule_recurse(rule_ant, input_list, TESTMODE)[0] #get firing strength if TESTMODE: print 'FIRING STREGTH, RULE', rule.rule_id, ':', fs output = copy.deepcopy(self.outputs[rule_con[0]].MFs[rule_con[2]]) #get output output[1] = self.implicate(fs, output)#use implication to get fuzzy consequent if TESTMODE: self.implicatedOutputs[rule.rule_id][self.outputs[rule_con[0]].name] = copy.deepcopy(output) outs.append(output) #aggregate outputs if len(outs) > 0: output_result = self.aggregate(outs) #aggregate outputs if there are outputs if self.defuzz <> None: #defuzzify outputs output_result = fuzz.defuzz(output_result[0], output_result[1], self.defuzz) else: m1 = self.outputs[output_key].data_range[0] #get output min m2 = self.outputs[output_key].data_range[1] #get output max x1 = np.arange(m1,m2,0.01) #get x range output_result = [x1, np.asarray([0 for i in range(len(x1))])] #return mf function of zeros if self.defuzz <> None: #defuzzify outputs output_result = [0,0] return output_result
def get_extension(self, arriving_green_light_car, behind_red_light_car, extension_count): behind_red_light_level_few = fuzz.interp_membership(self.x_behind_red_light, self.behind_red_light_few, behind_red_light_car) behind_red_light_level_small = fuzz.interp_membership(self.x_behind_red_light, self.behind_red_light_small, behind_red_light_car) behind_red_light_level_medium = fuzz.interp_membership(self.x_behind_red_light, self.behind_red_light_medium, behind_red_light_car) behind_red_light_level_many = fuzz.interp_membership(self.x_behind_red_light, self.behind_red_light_many, behind_red_light_car) arriving_green_light_level_few = fuzz.interp_membership(self.x_arriving_green_light, self.arriving_green_light_few, arriving_green_light_car) arriving_green_light_level_small = fuzz.interp_membership(self.x_arriving_green_light, self.arriving_green_light_small, arriving_green_light_car) arriving_green_light_level_medium = fuzz.interp_membership(self.x_arriving_green_light, self.arriving_green_light_medium, arriving_green_light_car) arriving_green_light_level_many = fuzz.interp_membership(self.x_arriving_green_light, self.arriving_green_light_many, arriving_green_light_car) # Rule 1: If Arrival is few then Extension is zero. # Rule 2: If Arrival is small AND Queue is (few OR small) then Extension is short. # Rule 3: If Arrival is small AND Queue is (medium OR many) then Extension is zero. # Rule 4: If Arrival is medium AND Queue is (few OR small) then Extension is medium. # Rule 5: If Arrival is medium AND Queue is (medium OR many) then Extension is short. # Rule 6: If Arrival is many AND Queue is few then Extension is long. # Rule 7: If Arrival is many AND Queue is (small OR medium) then Extension is medium. # Rule 8: If Arrival is few AND Queue is many then Extension is short. rule1 = arriving_green_light_level_few rule2 = np.fmin(arriving_green_light_level_small, np.fmax(behind_red_light_level_few, behind_red_light_level_small)) rule3 = np.fmin(arriving_green_light_level_small, np.fmax(behind_red_light_level_medium, behind_red_light_level_many)) rule4 = np.fmin(arriving_green_light_level_medium, np.fmax(behind_red_light_level_few, behind_red_light_level_small)) rule5 = np.fmin(arriving_green_light_level_medium, np.fmax(behind_red_light_level_medium, behind_red_light_level_many)) rule6 = np.fmin(arriving_green_light_level_many, behind_red_light_level_few) rule7 = np.fmin(arriving_green_light_level_many, np.fmax(behind_red_light_level_small, behind_red_light_level_medium)) rule8 = np.fmin(arriving_green_light_level_many, behind_red_light_level_many) if extension_count == 0: extension_activation_zero = np.fmin(np.fmax(rule1, rule3), self.extension_zero) extension_activation_short = np.fmin(np.fmax(rule2, np.fmax(rule5, rule8)), self.extension_short) extension_activation_medium = np.fmin(np.fmax(rule4, rule7), self.extension_medium) extension_activation_long = np.fmin(rule6, self.extension_long) else: extension_activation_zero = np.fmin( np.fmax(rule1, np.fmax(rule2, np.fmax(rule3, np.fmax(rule5, rule8)))), self.extension_zero) extension_activation_short = np.fmin(np.fmax(rule4, rule7), self.extension_short) extension_activation_medium = np.fmin(rule6, self.extension_medium) extension_activation_long = np.fmin(0, self.extension_long) aggregated = np.fmax(extension_activation_zero, np.fmax(extension_activation_short, np.fmax(extension_activation_medium, extension_activation_long))) return fuzz.defuzz(self.x_extension, aggregated, 'centroid')
def rule_actividad(value, graficar=False): # recibe los datos para poder seguir el proceso difuso para encontrar la pertenencia # retorna el valor al que pertenece en la clase segun la hora mf_actividad = generar_actividad(False) mf_calorico = generar_calorico(False) # se usa para encontrar los grados de pertenencia del valor, borrificacion actividad_nivel_rest = fuzz.interp_membership(mf_actividad['intensity'], mf_actividad['rest'], value) actividad_nivel_std = fuzz.interp_membership(mf_actividad['intensity'], mf_actividad['active'], value) actividad_nivel_work = fuzz.interp_membership(mf_actividad['intensity'], mf_actividad['workout'], value) # regla: si rest -> low rest_activation = np.fmin(actividad_nivel_rest, mf_calorico['low']) # regla: si active -> std active_activation = np.fmin(actividad_nivel_std, mf_calorico['standard']) # regla: si workout -> high workout_activation = np.fmin(actividad_nivel_work, mf_calorico['high']) # deborrificacion agregado = np.fmax(rest_activation, np.fmax(active_activation, workout_activation)) caloric = fuzz.defuzz(mf_calorico['caloric'], agregado, 'centroid') # # graficar # if graficar: # select_caloric = fuzz.interp_membership(mf_calorico['caloric'], agregado, caloric) # caloric0 = np.zeros_like(mf_calorico['caloric']) # fig, ax0 = plt.subplots(figsize=(8, 3)) # # ax0.plot(mf_calorico['caloric'], mf_calorico['low'], 'b', linewidth=0.5, linestyle='--', label='Low') # ax0.plot(mf_calorico['caloric'], mf_calorico['standard'], 'g', linewidth=0.5, linestyle='--', label='Standard') # ax0.plot(mf_calorico['caloric'], mf_calorico['high'], 'r', linewidth=0.5, linestyle='--', label='High') # ax0.fill_between(mf_calorico['caloric'], caloric0, agregado, facecolor='Orange', alpha=0.7) # ax0.plot([caloric, caloric], [0, select_caloric], 'k', linewidth=1.5, alpha=0.9) # ax0.set_title('Dish Classification and Result (line)') # ax0.legend() # # Turn off top/right axes # for ax in (ax0,): # ax.spines['top'].set_visible(False) # ax.spines['right'].set_visible(False) # ax.get_xaxis().tick_bottom() # ax.get_yaxis().tick_left() # # plt.tight_layout() # #fig.savefig('graphs/result_calorico.png', bbox_inches='tight') # return caloric, "caloric"
def rule_hora(hour, graficar=False): # recibe los datos para poder seguir el proceso difuso para encontrar la pertenencia # retorna el valor al que pertenece en la clase segun la hora mf_hora = generar_hora(False) mf_clase = generar_clase(False) # se usa para encontrar los grados de pertenencia del valor, borrificacion hora_nivel_morn = fuzz.interp_membership(mf_hora['horario'], mf_hora['morning'], hour) hora_nivel_aft = fuzz.interp_membership(mf_hora['horario'], mf_hora['afternoon'], hour) hora_nivel_eve = fuzz.interp_membership(mf_hora['horario'], mf_hora['evening'], hour) # regla: si manana -> desayuno breakfast_activation = np.fmin(hora_nivel_morn, mf_clase['breakfast']) # regla: si medio dia -> almuerzo lunch_activation = np.fmin(hora_nivel_aft, mf_clase['lunch']) # regla: si medio dia -> almuerzo dinner_activation = np.fmin(hora_nivel_eve, mf_clase['dinner']) # deborrificacion agregado = np.fmax(breakfast_activation, np.fmax(lunch_activation, dinner_activation)) clase = fuzz.defuzz(mf_clase['clase'], agregado, 'centroid') # graficar # if graficar: # select_clase = fuzz.interp_membership(mf_clase['clase'], agregado, clase) # clase0 = np.zeros_like(mf_clase['clase']) # fig, ax0 = plt.subplots(figsize=(8, 3)) # # ax0.plot(mf_clase['clase'], mf_clase['breakfast'], 'b', linewidth=0.5, linestyle='--', label='Breakfast') # ax0.plot(mf_clase['clase'], mf_clase['lunch'], 'g', linewidth=0.5, linestyle='--', label='Lunch') # ax0.plot(mf_clase['clase'], mf_clase['dinner'], 'r', linewidth=0.5, linestyle='--', label='Dinner') # ax0.fill_between(mf_clase['clase'], clase0, agregado, facecolor='Orange', alpha=0.7) # ax0.plot([clase, clase], [0, select_clase], 'k', linewidth=1.5, alpha=0.9) # ax0.set_title('Dish Classification and Result (line)') # ax0.legend() # # Turn off top/right axes # for ax in (ax0,): # ax.spines['top'].set_visible(False) # ax.spines['right'].set_visible(False) # ax.get_xaxis().tick_bottom() # ax.get_yaxis().tick_left() # # plt.tight_layout() # #fig.savefig('graphs/result_clase.png', bbox_inches='tight') # return clase, "clase"
def make_decision(market_value, location, assets, income, interest, verbose=0): credit = apply_all_rules(market_value, location, assets, income, interest, verbose) # defuzzification with mean of maximum defuzz_credit = fuzz.defuzz(x_credit, credit, 'mom') max_n = np.max(credit) if (verbose == 1): plt.rcParams["figure.figsize"] = 15, 5 plt.plot(x_credit, credit_very_low, 'c', linestyle='--', linewidth=1.5, label='Very Low') plt.plot(x_credit, credit_low, 'b', linestyle='--', linewidth=1.5, label='Low') plt.plot(x_credit, credit_medium, 'g', linestyle='--', linewidth=1.5, label='Medium') plt.plot(x_credit, credit_high, 'r', linestyle='--', linewidth=1.5, label='High') plt.plot(x_credit, credit_very_high, 'y', linestyle='--', linewidth=1.5, label='Very High'), plt.title("Credit Value $ x10^3") plt.legend() plt.fill_between(x_credit, credit, color='b') plt.ylim(-0.1, 1.1) plt.grid(True) plt.plot(defuzz_credit, max_n, 'X', color='r') plt.show() print "Output: ", defuzz_credit, "x10^3 $" return defuzz_credit
def run(self): """ Finds appropriate value of pid gains NO arguments : inputs : List to contain discrete values of io variables in their range (step size = 1) for plotting. i.e, x axis inputs[0] = ERROR AXIS ., so stores all possible error values inputs[1] = DEL_ERROR AXIS ., ,, inputs[2] = CONTROL_OUTPUT AXIS ., ,, b : 3d list, each layer (i.e, 2d list) contains 1d lists of y-values (in x of step size 1) of a particular fuzzy subset of a particular i/o variable muval_de, muval_e: Stores membership value of error and delta_error for each fuzzy subsets ERROR DEL_ERROR CONTROL_OUTPUT m_value for crisp e and delta_e values b[0][0] -ve Medium || b[1][0] -ve Medium || b[2][0] -ve Medium .. muval[0] | muval_d[0] b[0][1] -ve small || b[1][1] -ve small || b[2][1] -ve small .. muval[1] | muval_d[1] b[0][2] zero || b[1][2] zero || b[2][2] zero .. muval[2] | muval_d[2] b[0][3] +ve small || b[1][3] +ve small || b[2][3] +ve small .. muval[3] | muval_d[3] b[0][4] +ve Medium || b[1][4] +ve Medium || b[2][4] +_ve Medium .. muval[4] | muval_d[4] f_mat is a 2d matrix containing rule strengths """ inputs = [ np.arange(var[0], var[1]+1, 1) for var in self.io_ranges] b = [] for i in range(3) : b.append( [membership_f(self.mf_types[i], inputs[i], a) for a in self.f_ssets[i] ]) # visualize.visualize_mf(b,inputs) # fuzzify Error and delta error to obtain their membership values for corr. fuzzy subsets muval_e = fuzzify(inputs[0], b[0], self.error) muval_de = fuzzify(inputs[1], b[1], self.delta_e) # print 'muval_e:', muval_e # print 'muval_de:', muval_de # Obtain the rule strength matrix f_mat = fuzzy_matrix(muval_e, muval_de) # obtian the y value clipped by output activation for output fuzzy subsets output = rule_base(b, f_mat) aggregated = np.fmax(output[0], np.fmax(output[1],np.fmax(output[2], np.fmax(output[3], output[4])))) out_final = fuzz.defuzz(inputs[2], aggregated, 'centroid') print "output:",out_final # plotting final output visualize.visualize_output(b, inputs, output, out_final, aggregated) plt.show()
def game_type(player, comp): """ A fuzzy algorithm to define the offensiveness and/or defensiveness of the game. Determines how aggressive the fuzzy player is""" score_diff = float(player-comp) ### Inputs ### # Input Variable Domain score = np.arange(-21, 21, 1) # Input membership functions score_ahead = fuzz.gaussmf(score, -21, 8.823) score_tied = fuzz.gaussmf(score, 0, 9.012) score_behind = fuzz.gaussmf(score, 21, 8.823) # Fuzzifying the current input def score_category(sc): score_cat_ahead = fuzz.interp_membership(score, score_ahead, sc) score_cat_tied = fuzz.interp_membership(score, score_tied, sc) score_cat_behind = fuzz.interp_membership(score, score_behind, sc) return dict(ahead = score_cat_ahead, tied = score_cat_tied, behind = score_cat_behind) ### Outputs ### # Output Variable Domain game = np.arange(0, 1, 1) # Output membership functions game_defensive = fuzz.gaussmf(game, 0, 0.162899) game_offensive = fuzz.gauss2mf(game, 0.30291, 0.090976, 1.31, 0.416) ### Rules ### current_score = score_category(score_diff) # Going to make this a hard opponent, so if the score is tied or # if the human is winning, it will play offensively rule1 = current_score['ahead'] rule2 = np.fmax(current_score['tied'], current_score['behind']) # Apply implication operator (Mamdami) imp1 = np.fmin(rule1, game_defensive) imp2 = np.fmin(rule2, game_offensive) # Aggregate outputs using max aggregate_membership = np.fmax(imp1, imp2) # Defuzzify using centroid and return the result result_game = fuzz.defuzz(game, aggregate_membership, 'centroid') return result_game
def calculate_pi3k(egfr_mfs, erk_mfs, pi3k_mfs, pi3k, egfr_index, erk_index): a1 = egfr_mfs[0][egfr_index] c1 = np.fmin(a1, pi3k_mfs[0]) a2 = erk_mfs[1][erk_index] c2 = np.fmin(a2, pi3k_mfs[0]) c_com = np.fmax(c1, c2) a3_1 = egfr_mfs[1][egfr_index] a3_2 = erk_mfs[0][erk_index] a3 = min(a3_1, a3_2) c3 = np.fmin(a3, pi3k_mfs[1]) c_com = np.fmax(c_com, c3) try: pi3k_val = fuzz.defuzz(pi3k, c_com, 'centroid') except AssertionError as e: pi3k_val = 0 return pi3k_val
def calculate_raf(egfr_mfs, akt_mfs, raf_mfs, raf, egfr_index, akt_index): a1 = egfr_mfs[1][egfr_index] c1 = np.fmin(a1, raf_mfs[1]) a2 = akt_mfs[1][akt_index] c2 = np.fmin(a2, raf_mfs[1]) c_com = np.fmax(c1, c2) a3_1 = egfr_mfs[0][egfr_index] a3_2 = akt_mfs[0][akt_index] a3 = min(a3_1, a3_2) c3 = np.fmin(a3, raf_mfs[0]) c_com = np.fmax(c_com, c3) try: raf_val = fuzz.defuzz(raf, c_com, 'centroid') except AssertionError as e: raf_val = 0 return raf_val
def defuzz(self): """Derive crisp value based on membership of adjective(s).""" ups_universe, output_mf, cut_mfs = self.find_memberships() if len(cut_mfs) == 0: raise ValueError("No terms have memberships. Make sure you " "have at least one rule connected to this " "variable and have run the rules calculation.") try: return defuzz(ups_universe, output_mf, self.var.defuzzify_method) except AssertionError: raise ValueError("Crisp output cannot be calculated, likely " "because the system is too sparse. Check to " "make sure this set of input values will " "activate at least one connected Term in each " "Antecedent via the current set of Rules.")
def test_defuzz(): x = np.arange(21) - 10 gmf = fuzz.gaussmf(x, 0, 2) assert_allclose(0, fuzz.defuzz(x, gmf, 'centroid'), atol=1e-9) assert_allclose(0, fuzz.defuzz(x, gmf, 'bisector')) assert_allclose(0, fuzz.defuzz(x, gmf, 'mom')) assert_allclose(0, fuzz.defuzz(x, gmf, 'som')) assert_allclose(0, fuzz.defuzz(x, gmf, 'lom')) # Fuzzy plateau to differentiate mom, som, lom trapmf = fuzz.trapmf(x, [-1, 3, 7, 8]) assert_allclose(3, fuzz.defuzz(x, trapmf, 'som')) assert_allclose(5, fuzz.defuzz(x, trapmf, 'mom')) assert_allclose(7, fuzz.defuzz(x, trapmf, 'lom')) # Bad string argument assert_raises(ValueError, fuzz.defuzz, x, trapmf, 'bad string')
def throttle_command(speed_read): # Universe of discourse speed = np.arange(60,150,.1) throttle_value = np.arange(0,1,0.01) # Input membership functions too_slow = fuzz.trapmf(speed,[60,60,80,85]) slow = fuzz.trimf(speed,[83,90,97]) cruise = fuzz.trimf(speed,[95,100,105]) fast = fuzz.trimf(speed,[103,110,117]) too_fast = fuzz.trapmf(speed,[115,120,150,150]) # Output membership functions very_low = fuzz.trimf(throttle_value,[0,0,0.15]) low = fuzz.trimf(throttle_value,[0.1,0.25,0.4]) medium = fuzz.trimf(throttle_value,[0.35,0.5,0.65]) high = fuzz.trimf(throttle_value,[0.6,0.75,0.9]) very_high = fuzz.trimf(throttle_value,[0.85,1,1]) # membership values speed_cat_too_slow = fuzz.interp_membership(speed,too_slow,speed_read) speed_cat_slow = fuzz.interp_membership(speed,slow,speed_read) speed_cat_cruise = fuzz.interp_membership(speed,cruise,speed_read) speed_cat_fast = fuzz.interp_membership(speed,fast,speed_read) speed_cat_too_fast = fuzz.interp_membership(speed,too_fast,speed_read) # If part of rules rule1 = speed_cat_too_slow rule2 = speed_cat_slow rule3 = speed_cat_cruise rule4 = speed_cat_fast rule5 = speed_cat_too_fast # Then part of rules imp1 = np.fmin(rule1,very_high) imp2 = np.fmin(rule2,high) imp3 = np.fmin(rule3,medium) imp4 = np.fmin(rule4,low) imp5 = np.fmin(rule5,very_low) aggregate_membership = np.fmax(imp1,np.fmax(imp2,np.fmax(imp3,np.fmax(imp4,imp5)))) return fuzz.defuzz(throttle_value,aggregate_membership,'centroid')
def compute_egfr(egf_value, hrg_value, time_value, initial_values, mfs ): """Rules--- If egf is high or hrg is high and time is high then egfr is high if egf is low and hrg is low or time is low then egfr is low""" a1_1 = mfs[0][1][initial_values[0] == egf_value] #egf_high[egf == egf_value] a1_2 = mfs[1][1][ initial_values[1] == hrg_value ] #hrg_high[hrg == hrg_value] a1_3 = mfs[3][1][ initial_values[3] == time_value] if( a1_1.size == 0): a1_1 = mfs[0][1][ find_closest(initial_values[0], egf_value)] if( a1_2.size == 0): a1_2 = mfs[1][1][ find_closest(initial_values[1], hrg_value)] if( a1_3.size == 0): a1_3 = mfs[3][1][ find_closest(initial_values[3], time_value)] a1 = max( a1_1, a1_2) a1 = min(a1, a1_3 ) c1 = np.fmin(np.linspace(a1, a1, 100), mfs[2][1]) a2_1 = mfs[0][0][initial_values[0] == egf_value] #egf_low[egf == egf_value] a2_2 = mfs[1][0][initial_values[1] == hrg_value] #hrg_low[hrg == hrg_value] a2_3 = mfs[3][0][initial_values[3] == time_value] if( a2_1.size == 0): a2_1 = mfs[0][0][ find_closest(initial_values[0], egf_value)] if( a2_2.size == 0): a2_2 = mfs[1][0][ find_closest(initial_values[1], hrg_value)] if( a2_3.size == 0): a2_3 = mfs[3][0][ find_closest(initial_values[3], hrg_value)] a2 = min(a2_1, a2_2) a2 = max(a2, a2_3) c2 = np.fmin(np.linspace(a2,a2,100), mfs[2][0]) c_com = np.fmax(c1, c2) a = fuzz.defuzz(initial_values[2], c_com, 'centroid') return a
def compute_raf(egfr_value, akt_value, time_value, initial_values, mfs): """Rules--- If egfr is high or akt is high and time is high then raf is high if egfr is low and akt is low or time is low then raf is low""" a1_1 = mfs[0][1][initial_values[0] == egfr_value] #egfr_high[egfr == egfr_value] a1_2 = mfs[1][1][initial_values[1] == akt_value] #akt_high[akt == akt_value] a1_3 = mfs[3][1][initial_values[3] == time_value] if( a1_1.size == 0): a1_1 = mfs[0][1][ find_closest(initial_values[0], egfr_value)] if( a1_2.size == 0): a1_2 = mfs[1][1][ find_closest(initial_values[1], akt_value)] if(a1_3.size == 0): a1_3 = mfs[3][1][ find_closest(initial_values[3], time_value)] a1 = max( a1_1 , a1_2 ) a1 = min(a1_3, a1) #print egfr_value c1 = np.fmin( np.linspace(a1, a1, 100), mfs[2][1]) a2_1 = mfs[0][0][initial_values[0] == egfr_value] #egfr_low[egfr == egfr_value] a2_2 = mfs[1][0][initial_values[1] == akt_value] #akt_low[akt == akt_value] a2_3 = mfs[3][0][initial_values[3] == time_value] if( a2_1.size == 0): a2_1 = mfs[0][0][ find_closest(initial_values[0], egfr_value)] if( a2_2.size == 0): a2_2 = mfs[1][0][ find_closest(initial_values[1], akt_value)] if( a2_3.size == 0): a2_3 = mfs[3][0][ find_closest(initial_values[3], time_value)] a2 = min(a2_1 ,a2_2 ) a2 = max(a2_3, a2) c2 = np.fmin( np.linspace(a2, a2, 100), mfs[2][0]) c_com = np.fmax(c1, c2) return fuzz.defuzz(initial_values[2], c_com, 'centroid')
def calculate(self, p, i, d): """ Calculates the fuzzy output gain """ # Calculate membership value for each function if self.p_range is not None: p_interp = {k: interp_membership(self.p_range, mf, p) for k, mf in self.p_mf.iteritems()} print max(p_interp.iteritems(), key=operator.itemgetter(1))[0] else: p_interp = {} if self.i_range is not None: i_interp = {k: interp_membership(self.i_range, mf, i) for k, mf in self.i_mf.iteritems()} print max(i_interp.iteritems(), key=operator.itemgetter(1))[0] else: i_interp = {} if self.d_range is not None: d_interp = {k: interp_membership(self.d_range, mf, d) for k, mf in self.d_mf.iteritems()} print max(d_interp.iteritems(), key=operator.itemgetter(1))[0] else: d_interp = {} # Merge rule-bases dicts = [p_interp, i_interp, d_interp] super_dict = {} for k in set(k for d in dicts for k in d): super_dict[k] = [d[k] for d in dicts if k in d] # Generated inferences by rule implications aggregate_membership = np.zeros(len(self.c_range)) for a,b,c in self.c_rules: try: impl = np.fmin(super_dict[a], super_dict[b]) * self.c_mf[c] aggregate_membership = np.fmax(impl, aggregate_membership) except: pass c = defuzz(self.c_range, aggregate_membership, 'centroid') return c # this is the resulting "value" of the current state
if i < 8: ax.set_xticklabels([]) ax.text(np.average(system_evals[i][4]), 0.8, system_names[i], rotation=90, fontsize=10) ax.xaxis.grid(True) if i == 0: ax.legend(['DFES Output', 'Benchmark MF', 'Benchmark Range'], bbox_to_anchor=(1.85, 1.38), ncol=3, fontsize=12) plt.subplots_adjust(left=0.09, bottom=0.08, right=0.94, top=0.94, wspace=None, hspace=0.18) ### PLOT GWT results fig = plt.figure(figsize=(10,8)) res_ind = 4 alpha = 1.0 for i in range(len(results)): ax = plt.subplot(5,2,i+1) ax.plot(results[i][res_ind][0],results[i][res_ind][1], lw=2.0) cent = fuzz.defuzz(np.array(results[i][res_ind][0]), np.array(results[i][res_ind][1]), 'centroid') plt.plot([cent, cent], [0.0,2.0], '-r', lw=2.5) ax.set_ylim([0.0, 1.01]) ax.set_yticks([0.0, 0.5, 1.0]) ax.set_ylabel(r' $\mu(x)$') #ax.set_xticks([5000, 10000, 15000, 20000]) ax.set_xticks([5000, 10000, 15000, 20000, 25000, 30000, 35000, 40000, 45000]) ax.set_xticklabels([5, 10, 15, 20, 25, 30, 35, 40, 45]) #ax.set_xlim([1000,25000]) if i > 7: ax.set_xlabel('Gross Weight (x1000 lbs)') if i < 8: ax.set_xticklabels([]) ax.grid(True) plt.subplots_adjust(left=0.09, bottom=0.08, right=0.94, top=0.94, wspace=None, hspace=0.18) ### PLOT Pinst results fig = plt.figure(figsize=(10,8))
def test1(): test_name = 'SYS: In:7-2 Out:9-2 DATA: In:3 Out:3' print "*************************************" print "TESTING: ", test_name inMFs = input_7gaussMFs #system in outMFs = output_9gaussMFs defuzz = None outForm = 'tri' inDataForm = 'tri' outDataForm = 'tri' errType = 'fuzzy' input_arrays, output_arrays = generate_MFs(inMFs, outMFs) inputMFs = { ('VL_SYS_UNION', 'phi'): copy.deepcopy(input_arrays['phi']),('FWD_SYS_UNION', 'phi'): copy.deepcopy(input_arrays['phi']), ('WING_SYS_TYPE', 'phi'): copy.deepcopy(input_arrays['phi']),('ENG_SYS_TYPE', 'phi'): copy.deepcopy(input_arrays['phi']), ('VL_SYS_UNION', 'w'): copy.deepcopy(input_arrays['w']),('VL_SYS_TYPE', 'TP'): copy.deepcopy(input_arrays['TP']),('WING_SYS_TYPE', 'WS'): copy.deepcopy(input_arrays['WS']),('VL_SYS_PROP', 'sigma'): copy.deepcopy(input_arrays['sigma']), ('VL_SYS_TYPE', 'e_d'): copy.deepcopy(input_arrays['e_d']),('VL_SYS_DRV', 'eta_d'): copy.deepcopy(input_arrays['eta_d']),('FWD_SYS_DRV', 'eta_d'): copy.deepcopy(input_arrays['eta_d']),('FWD_SYS_PROP', 'eta_p'): copy.deepcopy(input_arrays['eta_p']), } inputPARAMs = { ('VL_SYS_UNION', 'phi'): copy.deepcopy(inMFs['phi']), ('FWD_SYS_UNION', 'phi'): copy.deepcopy(inMFs['phi']),('WING_SYS_TYPE', 'phi'): copy.deepcopy(inMFs['phi']),('ENG_SYS_TYPE', 'phi'): copy.deepcopy(inMFs['phi']), ('VL_SYS_UNION', 'w'): copy.deepcopy(inMFs['w']), ('VL_SYS_TYPE', 'TP'): copy.deepcopy(inMFs['TP']),('WING_SYS_TYPE', 'WS'): copy.deepcopy(inMFs['WS']), ('VL_SYS_PROP', 'sigma'): copy.deepcopy(inMFs['sigma']), ('VL_SYS_TYPE', 'e_d'): copy.deepcopy(inMFs['e_d']),('VL_SYS_DRV', 'eta_d'): copy.deepcopy(inMFs['eta_d']),('FWD_SYS_DRV', 'eta_d'): copy.deepcopy(inMFs['eta_d']),('FWD_SYS_PROP', 'eta_p'): copy.deepcopy(inMFs['eta_p']), } outputMFs = {'sys_phi' : copy.deepcopy(output_arrays['sys_phi'])} outputPARAMs = {'sys_phi' : copy.deepcopy(outMFs['sys_phi'])} combinedData = copy.deepcopy(data) print combinedData[0] #generate rules with Timer() as t: rule_grid = train_system(inputMFs, outputMFs, combinedData, inDataMFs=inDataForm, outDataMFs=outDataForm, ruleMethod=3) #write out FCL write_fcl_file_FRBS(inputPARAMs, outputPARAMs, rule_grid, defuzz, 'test_sys_phi.fcl') #get system inputs, outputs, rulebase, AND_operator, OR_operator, aggregator, implication, \ defuzz = build_fuzz_system('test_sys_phi.fcl') sys = Fuzzy_System(inputs, outputs, rulebase, AND_operator, OR_operator, aggregator, implication, defuzz) print '=> ', t.secs, 'secs to build', len(sys.rulebase), 'rules' #test system with Timer() as t: error = getError(combinedData, sys, inMF=inDataForm, outMF=outDataForm, sysOutType=errType) print '=> ', t.secs, 'secs to check error' print 'Total System Error:', sum([err[2] for err in error]) print 'Mean Square System Error:', (1.0/len(error))*sum([err[2]**2 for err in error]) print 'Root Mean Square System Error:', ( (1.0/len(error)) * sum([err[2]**2 for err in error]) )**0.5 #actual vs. predicted plot plt.figure() plt.title('Actual vs. Predicted at Max Alpha Cut'+test_name) for err in error: if outDataForm == 'gauss': AC_actual = fuzzyOps.alpha_cut(0.8, [err[0][0],err[0][1]]) else: AC_actual = fuzzyOps.alpha_at_val(err[0][0],err[0][1]) if outForm == 'gauss': AC_pred = fuzzyOps.alpha_cut(0.8, (err[1][0],err[1][1])) else: AC_pred = fuzzyOps.alpha_at_val(err[1][0],err[1][1]) plt.scatter(AC_actual[0], AC_pred[0], marker='o', c='r') plt.scatter(AC_actual[1], AC_pred[1], marker='x', c='b') plt.plot([1,9],[1,9], '--k') plt.xlim([1,9]) plt.ylim([1,9]) plt.xlabel('Actual') plt.ylabel('Predicted') #visuzlize system with random data point #i = random.randrange(0, len(combinedData)) #inputs = {key[0]+"_"+key[1]:combinedData[i][0][key] for key in combinedData[i][0]} #sys.run(inputs, TESTMODE=True) #check random data points (9) plt.figure() plt.title('Random Tests:'+test_name) for j in range(9): i = random.randrange(0, len(combinedData)) inputs = {key[0]+"_"+key[1]:combinedData[i][0][key] for key in combinedData[i][0]} sysOut = sys.run(inputs) sysOut = sysOut[sysOut.keys()[0]] plt.subplot(3,3,j+1) plt.plot(sysOut[0], sysOut[1], '-r') plt.plot(combinedData[i][2][0], combinedData[i][2][1], '--k') plt.ylim([0,1.1]) plt.xlim([1,9]) #actual vs. error plot plt.figure() plt.title('Actual (Centroid) vs. Error'+test_name) cents = [fuzz.defuzz(err[0][0], err[0][1], 'centroid') for err in error] plt.scatter(cents, [err[2] for err in error]) plt.xlabel('Actual (Centroid)') plt.ylabel('Fuzzy Error')