def __init__(self): # INPUTY self.buildingType = ctrl.Antecedent(np.arange(0, 400, 1), "Technologia budynku") self.wearWater = ctrl.Antecedent(np.arange(0, 500, 0.1), "Zuzycie wody na osobe") self.zone = ctrl.Antecedent(np.arange(15, 25, 0.01), "Strefa klimatyczna") self.isolation = ctrl.Antecedent(np.arange(1, 100, 1), "Procentowa termoizolacja budynku") self.surface = ctrl.Antecedent(np.arange(20, 150, 0.01), "Powierzchnia grzewcza") # OUTPUTY self.typeFurnance = ctrl.Consequent(np.arange(1, 100, 1), "Rodzaj pieca") # MEMBERSHIPS FUN self.buildingType['starebudownictwo'] = fuzz.trapmf(self.buildingType.universe, [170, 350, 400, 400]) self.buildingType['70-85'] = fuzz.gaussmf(self.buildingType.universe, 260, 25) self.buildingType['86-92'] = fuzz.gaussmf(self.buildingType.universe, 200, 20) self.buildingType['93-97'] = fuzz.gaussmf(self.buildingType.universe, 160, 15) self.buildingType['98-07'] = fuzz.gaussmf(self.buildingType.universe, 120, 15) self.buildingType['energooszczedny'] = fuzz.gaussmf(self.buildingType.universe, 80, 15) self.buildingType['niskoenegetyczny'] = fuzz.gaussmf(self.buildingType.universe, 45, 10) self.buildingType['pasywny'] = fuzz.trapmf(self.buildingType.universe, [0, 0, 15, 100]) # ---------------------- self.wearWater['1 osoba'] = fuzz.zmf(self.wearWater.universe, 20, 80) self.wearWater['2 osoba'] = fuzz.gaussmf(self.wearWater.universe, 100, 30) self.wearWater['3 osoba'] = fuzz.gaussmf(self.wearWater.universe, 150, 30) self.wearWater['4 osoba'] = fuzz.gaussmf(self.wearWater.universe, 200, 40) self.wearWater['5 osoba'] = fuzz.gaussmf(self.wearWater.universe, 250, 50) self.wearWater['6 osoba'] = fuzz.gaussmf(self.wearWater.universe, 300, 60) self.wearWater['7 osoba'] = fuzz.gaussmf(self.wearWater.universe, 350, 60) self.wearWater['8 osoba'] = fuzz.smf(self.wearWater.universe, 310, 470) # ---------------------- self.zone['Strefa 1'] = fuzz.gaussmf(self.zone.universe, 16, 0.5) self.zone['Strefa 2'] = fuzz.gaussmf(self.zone.universe, 18, 0.9) self.zone['Strefa 3'] = fuzz.gaussmf(self.zone.universe, 20, 1.5) self.zone['Strefa 4'] = fuzz.gaussmf(self.zone.universe, 22, 1.2) self.zone['Strefa 5'] = fuzz.gaussmf(self.zone.universe, 24, 0.45) # --------------------- self.surface['kawalerka'] = fuzz.zmf(self.surface.universe, 25, 65) self.surface['mieszkanie'] = fuzz.gaussmf(self.surface.universe, 75, 30) self.surface['apartament'] = fuzz.gaussmf(self.surface.universe, 111, 8) self.surface['dom_jednorodzinny'] = fuzz.gaussmf(self.surface.universe, 130, 3.5) self.surface['willa'] = fuzz.smf(self.surface.universe, 130, 150) # -------------------- self.isolation['brak'] = fuzz.zmf(self.isolation.universe, 5, 15) self.isolation['slabo'] = fuzz.gaussmf(self.isolation.universe, 20, 7) self.isolation['srednio'] = fuzz.gaussmf(self.isolation.universe, 50, 20) self.isolation['dobrze'] = fuzz.gaussmf(self.isolation.universe, 70, 10) self.isolation['doskonale'] = fuzz.smf(self.isolation.universe, 75, 95) self.typeFurnance['weglowy'] = fuzz.zmf(self.typeFurnance.universe, 4, 40) self.typeFurnance['gazowy'] = fuzz.gbellmf(self.typeFurnance.universe, 23, 2.5, 50) self.typeFurnance['pompa ciepla'] = fuzz.smf(self.typeFurnance.universe, 70, 100) # ----------------------- # RULES rules = [ ctrl.Rule(self.buildingType['pasywny'] & self.wearWater['4 osoba'] & self.surface['dom_jednorodzinny'] & self.isolation['doskonale'], self.typeFurnance['pompa ciepla']), ctrl.Rule(self.buildingType['starebudownictwo'] & self.wearWater['8 osoba'] & self.isolation['brak'] & self.surface['dom_jednorodzinny'], self.typeFurnance['weglowy']), ctrl.Rule(self.buildingType['starebudownictwo'] & self.wearWater['7 osoba'] & self.isolation['slabo'] & self.surface['dom_jednorodzinny'], self.typeFurnance['weglowy']), ctrl.Rule(self.buildingType['starebudownictwo'] & self.wearWater['6 osoba'] & self.isolation['slabo'] & self.surface['dom_jednorodzinny'], self.typeFurnance['weglowy']), ctrl.Rule(self.buildingType['70-85'] & self.wearWater['6 osoba'] & self.isolation['slabo'] & self.surface[ 'dom_jednorodzinny'], self.typeFurnance['weglowy']), ctrl.Rule(self.buildingType['niskoenegetyczny'] & self.wearWater['5 osoba'] & self.isolation['dobrze'] & self.surface['dom_jednorodzinny'] | self.surface['willa'], self.typeFurnance['pompa ciepla']), ctrl.Rule(self.buildingType['energooszczedny'] & self.wearWater['5 osoba'] & self.isolation['dobrze'] & self.surface['dom_jednorodzinny'] | self.surface['willa'], self.typeFurnance['pompa ciepla']), ctrl.Rule(self.buildingType['energooszczedny'] & self.wearWater['4 osoba'] & self.isolation['dobrze'] & self.surface['dom_jednorodzinny'] | self.surface['willa'], self.typeFurnance['pompa ciepla']), ctrl.Rule(self.buildingType['niskoenegetyczny'] & self.wearWater['5 osoba'] & self.isolation['dobrze'] & self.surface['dom_jednorodzinny'] | self.surface['willa'], self.typeFurnance['pompa ciepla']), ctrl.Rule(self.buildingType['93-97'] & self.wearWater['2 osoba'] & self.isolation['srednio'] & self.surface[ 'kawalerka'], self.typeFurnance['gazowy']), ctrl.Rule(self.buildingType['93-97'] & self.wearWater['3 osoba'] & self.isolation['srednio'] & self.surface[ 'mieszkanie'], self.typeFurnance['gazowy']), ctrl.Rule(self.buildingType['93-97'] & self.wearWater['4 osoba'] & self.isolation['srednio'] & self.surface[ 'mieszkanie'], self.typeFurnance['gazowy']), ctrl.Rule(self.buildingType['98-07'] & self.wearWater['2 osoba'] & self.isolation['srednio'] & self.surface[ 'kawalerka'], self.typeFurnance['gazowy']), ctrl.Rule(self.buildingType['98-07'] & self.wearWater['3 osoba'] & self.isolation['srednio'] & self.surface[ 'mieszkanie'], self.typeFurnance['gazowy']), ctrl.Rule(self.buildingType['98-07'] & self.wearWater['4 osoba'] & self.isolation['srednio'] & self.surface[ 'mieszkanie'], self.typeFurnance['gazowy']), ctrl.Rule(self.buildingType['98-07'] & self.wearWater['5 osoba'] & self.isolation['srednio'] & self.surface[ 'apartament'], self.typeFurnance['gazowy']), ] # Controll System self.typeControl = ctrl.ControlSystem(rules) self.type = ctrl.ControlSystemSimulation(self.typeControl)
def __init__(self, lowest=0, highest=40, step=0.5): super(ControlTemperature, self).__init__() self.lowest = lowest self.highest = highest self.step = step self.temp = np.arange(lowest, highest, step) self.temp_err = np.arange(-50, 50, 0.1) self.temp_roc = np.arange(-30, 30, 0.1) # degress c per minute self.chill_out = np.arange(-100, 100, 1) # self.heat_out = np.arange(0, 100, 1) #Current Temperature self.te_too_cold = fuzz.trapmf(self.temp_err, [-40, -30, -1.5, -1]) self.te_cold = fuzz.trimf(self.temp_err, [-1.5, -1, -0.5]) self.te_optimal = fuzz.trimf(self.temp_err, [-0.5, 0, 0.5]) self.te_hot = fuzz.trimf(self.temp_err, [0.5, 1, 1.5]) self.te_too_hot = fuzz.trapmf(self.temp_err, [1, 1.5, 30, 40]) #Temperature Rate of Change (deg C per minute) self.tr_cooling_quickly = fuzz.trapmf(self.temp_roc, [-20, -10, -0.5, -0.25]) # Output - Chiller self.co_off = fuzz.trimf(self.chill_out, [0, 0, 5]) self.co_low = fuzz.trimf(self.chill_out, [5, 20, 40]) self.co_medium = fuzz.trimf(self.chill_out, [20, 40, 60]) self.co_high = fuzz.trapmf(self.chill_out, [40, 60, 100, 100]) # Output - Heater self.ho_off = fuzz.trimf(self.chill_out, [-5, 0, 0]) self.ho_low = fuzz.trimf(self.chill_out, [-40, -20, -5]) self.ho_medium = fuzz.trimf(self.chill_out, [-60, -40, -20]) self.ho_high = fuzz.trapmf(self.chill_out, [-100, -100, -60, -40])
def __init__(self): # Generate universe functions self.distance = np.arange(0.,181.,1.) self.acceleration = np.arange(0.,0.1,0.01) # Generate Distance membership functions self.near = fuzz.trapmf(self.distance, (-1.,-1.,20.,65.)) self.medium = fuzz.trapmf(self.distance,(35.,80.,120.,135.)) self.far = fuzz.trapmf(self.distance,(105.,170.,180.,200.)) # Generate Acceleration membership functions self.slow = fuzz.trimf(self.acceleration, (-1.,0.,0.05)) self.normal = fuzz.trapmf(self.acceleration,(0.02,0.035,0.04,0.07)) self.fast = fuzz.trapmf(self.acceleration,(0.06,0.085,0.1,0.2)) # Fuzzy relation self.R1 = fuzz.relation_product(self.near,self.slow) self.R2 = fuzz.relation_product(self.medium,self.normal) self.R3 = fuzz.relation_product(self.far,self.fast) # Combine the fuzzy relation self.R_combined = np.fmax(self.R1, np.fmax(self.R2, self.R3)) self.thetaOne = 0.0 self.thetaTwo = 0.0 self.InputDistanceAngle = 0.0 self.OutputAcceleration = 0.0 self.visualize = True
def test_lambda_cut_boundaries(): x = np.arange(10) mfx = fuzz.trapmf(x, [0, 6, 7, 10]) assert_allclose(fuzz.lambda_cut_boundaries(x, mfx, 0.2), np.r_[1.2]) x = np.arange(11) mfx = fuzz.trapmf(x, [0, 6, 7, 10]) assert_allclose(fuzz.lambda_cut_boundaries(x, mfx, 0.2), np.r_[1.2, 9.4])
def membership_f(mf, x, abcd): """ Returns y values corresponding to type of type of Membership fn. arguments: mf - string containing type of Membership function x - x axis values """ if mf == "zmf": return fuzz.zmf(x, abcd[0], abcd[1]) # zmf(x, a, b) elif mf == "trimf": return fuzz.trimf(x, abcd[0:3]) # trimf(x, abc) elif mf == "dsigmf": return fuzz.dsigmf(x, abcd[0], abcd[1], abcd[2], abcd[3]) # dsigmf(x, b1, c1, b2, c2) elif mf == "gauss2mf": return fuzz.gauss2mf(x, abcd[0], abcd[1], abcd[2], abcd[3]) # gauss2mf(x, mean1, sigma1, mean2, sigma2) elif mf == "gaussmf": return fuzz.gaussmf(x, abcd[0], abcd[1]) # gaussmf(x, mean, sigma) elif mf == "gbellmf": return fuzz.gbellmf(x, abcd[0], abcd[1], abcd[2]) # gbellmf(x, a, b, c) elif mf == "piecemf": return fuzz.piecemf(x, abcd[0:3]) # piecemf(x, abc) elif mf == "pimf": return fuzz.pimf(x, abcd[0], abcd[1], abcd[2], abcd[3]) # pimf(x, a, b, c, d) elif mf == "psigmf": return fuzz.psigmf(x, abcd[0], abcd[1], abcd[2], abcd[3]) # psigmf(x, b1, c1, b2, c2) elif mf == "sigmf": return fuzz.sigmf(x, abcd[0], abcd[1]) # sigmf(x, b, c) elif mf == "smf": return fuzz.smf(x, abcd[0], abcd[1]) # smf(x, a, b) elif mf == "trapmf": return fuzz.trapmf(x, abcd) # trapmf(x, abcd)
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 rangeToMF(range, type): """ Translate the range into a list of x_values and an MF function. range : list/tuple range to translate to MF type : string type of MF: 'sing' - singleton MF 'gauss' - gaussian MF function (mean, standard deviation) 'tri' - triangular MF function 'trap' - trapezoidal MF function """ c = 100 #number of x points minR = float(min(range)) maxR = float(max(range)) if type == 'sing': #singleton c = 10 #special short mf for singleton if maxR == minR: #print "SAME R" ran = max(abs(0.15*minR),0.0001) xrange = [minR-ran, minR+ran, ran/c] Xs = [minR-2.*ran, minR-1.*ran, minR, minR+1.*ran, minR+2.*ran,] Ys = [0.0, 0.0, 1.0, 0.0, 0.0] else: ran = abs(maxR-minR) xrange = [minR, maxR, ran/c] Xs, Ys = singleton_to_fuzzy(sum(range)/len(range), xrange) elif type == 'gauss': #gaussian MF std_range = (1./4.) #0.25 if minR == maxR: ran = max(0.0001,abs(0.05*minR))#0.05 else: ran = abs(maxR - minR) #check for min=max and get range Xs = np.arange(minR - 0.5*ran, maxR + 0.5*ran, 2*ran/c) Ys = fuzz.gaussmf(Xs, sum(range)/len(range), std_range*(ran)) #gaussian mf with 4sigma = range (to 97.7% "certainty") elif type == 'tri': #triangular MF if minR == maxR: ran = max(abs(0.2*minR),0.001) xrange = [0.9*minR, 1.1*maxR, ran/c,] Xs, Ys = singleton_to_fuzzy(sum(range)/len(range), xrange) else: Xs = np.arange(0.9*minR, 1.1*maxR, (1.1*maxR-0.9*minR)/c) #create fuzzy MF for output Ys = fuzz.trimf(Xs, [minR, sum(range)/len(range), maxR]) elif type == 'trap': #trapezoidal MF if minR == maxR: ran = max(abs(0.2*minR),0.001) xrange = [0.9*minR, 1.1*maxR, ran/c,] Xs, Ys = singleton_to_fuzzy(sum(range)/len(range), xrange) else: Xs = np.arange(0.9*minR, 1.1*maxR, (1.1*maxR-0.9*minR)/c) #create fuzzy MF for output Ys = fuzz.trapmf(Xs, [minR, minR, maxR, maxR]) else: raise StandardError("Unknown type of membership function: %s" % type) return [np.asarray(Xs), np.asarray(Ys)] #create MF
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 eval_membership_function_akt(akt_values, positive_change_akt, negative_change_akt): '''Evaluates membership function for akt ''' akt_high = fuzz.gaussmf(akt_values, 1, 0.1) akt_low = fuzz.gaussmf(akt_values, 0, 0.3) akt_high1 = fuzz.trapmf(akt_values,(0.1,0.1,0.8,1.4)) positive_change_akt_high = fuzz.gaussmf(positive_change_akt, 1, 0.01) positive_change_akt_low = fuzz.gaussmf(positive_change_akt, 0, 0.01) negative_change_akt_high = fuzz.gaussmf(negative_change_akt, -1, 0.01) negative_change_akt_low = fuzz.gaussmf(negative_change_akt, 0, 0.01) return (akt_low, akt_high, positive_change_akt_low, positive_change_akt_high, negative_change_akt_low, negative_change_akt_high, akt_high1)
def eval_membership_function_erk(erk_values, positive_change_erk, negative_change_erk): '''Evaluates membership function for erk ''' erk_high = fuzz.gaussmf(erk_values, 1, 0.1) erk_low = fuzz.gaussmf(erk_values, 0, 0.1) erk_high1 = fuzz.trapmf(erk_values,(0.1,0.1,0.8,1.4)) positive_change_erk_high = fuzz.gaussmf(positive_change_erk, 1, 0.01) positive_change_erk_low = fuzz.gaussmf(positive_change_erk, 0, 0.01) negative_change_erk_high = fuzz.gaussmf(negative_change_erk, -1, 0.01) negative_change_erk_low = fuzz.gaussmf(negative_change_erk, 0, 0.01) return (erk_low, erk_high, positive_change_erk_low, positive_change_erk_high, negative_change_erk_low, negative_change_erk_high, erk_high1)
def eval_membership_function_pi3k(pi3k_values, positive_change_pi3k, negative_change_pi3k): '''Evaluates membership function for pi3k ''' pi3k_high = fuzz.gaussmf(pi3k_values, 1, 0.1) pi3k_low = fuzz.gaussmf(pi3k_values, 0, 0.1) pi3k_high1 = fuzz.trapmf(pi3k_values,(0.1,0.1,0.8,1.4)) positive_change_pi3k_high = fuzz.gaussmf(positive_change_pi3k, 1, 0.01) positive_change_pi3k_low = fuzz.gaussmf(positive_change_pi3k, 0, 0.01) negative_change_pi3k_high = fuzz.gaussmf(negative_change_pi3k, -1, 0.01) negative_change_pi3k_low = fuzz.gaussmf(negative_change_pi3k, 0, 0.01) return (pi3k_low, pi3k_high, positive_change_pi3k_low, positive_change_pi3k_high, negative_change_pi3k_low, negative_change_pi3k_high, pi3k_high1)
def eval_membership_function_egfr(egfr_values, positive_change_egfr, negative_change_egfr): '''Evaluates membership function for egfr ''' egfr_high = fuzz.gaussmf(egfr_values,1, 0.1) egfr_low = fuzz.gaussmf(egfr_values,0, 0.1) egfr_high1 = fuzz.trapmf(egfr_values,(0.1,0.1,0.8,1.4)) positive_change_egfr_high = fuzz.gaussmf(positive_change_egfr,1, 0.1) positive_change_egfr_low = fuzz.gaussmf(positive_change_egfr, 0, 0.1) negative_change_egfr_high = fuzz.gaussmf(negative_change_egfr, -1, 0.1) negative_change_egfr_low = fuzz.gaussmf(negative_change_egfr, 0, 0.1) return (egfr_low, egfr_high, positive_change_egfr_low, positive_change_egfr_high, negative_change_egfr_low, negative_change_egfr_high, egfr_high1)
def eval_membership_function_raf(raf_values, positive_change_raf, negative_change_raf): '''Evaluates membership function for raf ''' raf_high = fuzz.gaussmf(raf_values, 1, 0.1) raf_low = fuzz.gaussmf(raf_values, 0, 0.1) raf_high1 = fuzz.trapmf(raf_values,(0.1,0.1,0.8,1.4)) positive_change_raf_high = fuzz.gaussmf(positive_change_raf, 1, 0.01) positive_change_raf_low = fuzz.gaussmf(positive_change_raf, 0, 0.01) negative_change_raf_high = fuzz.gaussmf(negative_change_raf, -1, 0.01) negative_change_raf_low = fuzz.gaussmf(negative_change_raf, 0, 0.01) return (raf_low, raf_high, positive_change_raf_low, positive_change_raf_high, negative_change_raf_low, negative_change_raf_high, raf_high1)
def generar_actividad(graficar=False): # se coloca 11 para que numpy tome efectivamente 11 espacio [0 a 10] intensity = np.arange(0, 11, 1) # Marco Actividad (Entrada) rest = fuzz.trapmf(intensity, [0, 0, 2, 4]) active = fuzz.trapmf(intensity, [2, 4, 6, 8]) workout = fuzz.trapmf(intensity, [6, 8, 10, 10]) # if graficar: # # graficar el marco # fig, ax = plt.subplots() # ax.plot(intensity, rest, 'b', intensity, active, 'y', intensity, workout, 'r') # ax.set_ylabel('Fuzzy membership') # ax.set_xlabel('Activity Intensity (1 - 10)') # ax.set_ylim(-0.05, 1.05) # ax.set_xlim(0.0, 10) # #fig.savefig('graphs/actividad.png', bbox_inches='tight') # return {'intensity': intensity, 'rest': rest, 'active': active, 'workout': workout}
def generar_clase(graficar=False): # se usa para el marco de salida para ver que horario tendra el platillo clase = np.arange(0, 11, 1) # Marco Pertenencia (Salida) breakfast = fuzz.trapmf(clase, [0, 0, 2, 4]) lunch = fuzz.trapmf(clase, [2, 4, 6, 8]) dinner = fuzz.trapmf(clase, [6, 8, 10, 10]) # # if graficar: # # graficar el marco # fig, ax = plt.subplots() # ax.plot(clase, breakfast, 'b', clase, lunch, 'y', clase, dinner, 'r') # ax.set_ylabel('Fuzzy membership') # ax.set_xlabel('Dish Classification (1 - 10)') # ax.set_ylim(-0.05, 1.05) # ax.set_xlim(0.0, 10) # #fig.savefig('graphs/clase.png', bbox_inches='tight') return {'clase': clase, 'breakfast': breakfast, 'lunch': lunch, 'dinner':dinner}
def generar_calorico(graficar=False): # se usa para el marco de salida para ver que horario tendra el platillo caloric = np.arange(0, 800, 1) # Marco Pertenencia (Salida) low = fuzz.trapmf(caloric, [0, 0, 350, 550]) standard = fuzz.trapmf(caloric, [350, 450, 550, 650]) high = fuzz.trapmf(caloric, [550, 650, 800, 800]) # if graficar: # # graficar el marco # fig, ax = plt.subplots() # ax.plot(caloric, low, 'b', caloric, standard, 'y', caloric, high, 'r') # ax.set_ylabel('Fuzzy membership') # ax.set_xlabel('Caloric Classification (Calories)') # ax.set_ylim(-0.05, 1.05) # ax.set_xlim(0, 800) # #fig.savefig('graphs/calorico.png', bbox_inches='tight') return {'caloric': caloric, 'low': low, 'standard': standard, 'high':high}
def generar_hora(graficar=False): # debido que a el paquete de logica difusa no recibe flotantes, se expresara el # el tiempo como minutos (entero) 1 dia = 1440 minutos # no se toma el minuto 1440, que equivale a 24:00 ya incluido como hora 00:00 horario = np.arange(0, 1440, 1) # Marco hora (Entrada) morning = fuzz.trapmf(horario, [0, 0, 480, 720]) afternoon = fuzz.trapmf(horario, [480, 720, 960, 1200]) # trapecio evening = fuzz.trapmf(horario,[960, 1200, 1439, 1439]) # if graficar: # # graficar el marco # fig, ax = plt.subplots() # ax.plot(horario, morning, 'r', horario, afternoon, 'm', horario, evening, 'b') # ax.set_ylabel('Fuzzy membership') # ax.set_xlabel('Day (Minutes)') # ax.set_ylim(-0.05, 1.05) # ax.set_xlim(0.0, 1400) # #fig.savefig('graphs/hora.png', bbox_inches='tight') # return {'horario': horario, 'morning': morning, 'afternoon': afternoon, 'evening': evening}
def membership_f(mf, x, abc = [0,0,0], a = 1, b = 2, c = 3, d = 4, abcd = [0,0,0,0]): return { 'trimf' : fuzz.trimf(x, abc), # trimf(x, abc) 'dsigmf' : fuzz.dsigmf(x, a, b, c, d), # dsigmf(x, b1, c1, b2, c2) 'gauss2mf': fuzz.gauss2mf(x, a, b, c, d), # gauss2mf(x, mean1, sigma1, mean2, sigma2) 'gaussmf' : fuzz.gaussmf(x, a, b), # gaussmf(x, mean, sigma) 'gbellmf' : fuzz.gbellmf(x, a, b, c), # gbellmf(x, a, b, c) 'piecemf' : fuzz.piecemf(x, abc), # piecemf(x, abc) 'pimf' : fuzz.pimf(x, a, b, c, d), # pimf(x, a, b, c, d) 'psigmf' : fuzz.psigmf(x, a, b, c, d), # psigmf(x, b1, c1, b2, c2) 'sigmf' : fuzz.sigmf(x, a, b), # sigmf(x, b, c) 'smf' : fuzz.smf(x, a, b), # smf(x, a, b) 'trapmf' : fuzz.trapmf(x, abcd), # trapmf(x, abcd) 'zmf' : fuzz.zmf(x, a, b), # zmf(x, a, b) }[mf]
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 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 load_rules(self, filename): with open(filename, 'r') as jsonfile: rules = json.loads(jsonfile.read()) self.actions = rules['actions'] self.state = rules['state'] self.rules = rules['results'] self.x = np.arange(self.state['min'], self.state['max']) for subset, parts in self.rules.items(): aggregated = [] points = [] for n, v in parts.items(): print n if v['mf'] == 'tri': mf = fuzz.trimf(self.x, v['shp']) if v['mf'] == 'trap': mf = fuzz.trapmf(self.x, v['shp']) elif v['mf'] == 'gbell': mf = fuzz.gbellmf(self.x, v['shp']) aggregated.append(mf) points.append(v['pts']) self.rules[subset] = (aggregated, points)
def membership_f(mf, x, abc=[0, 0, 0], a=1, b=2, c=3, d=4, abcd=[0, 0, 0, 0]): """ Returns y values corresponding to type of type of Membership fn. arguments: mf - string containing type of Membership function x - x axis values abc - list containing triangular edge point x-values """ return { "trimf": fuzz.trimf(x, abc), # trimf(x, abc) "dsigmf": fuzz.dsigmf(x, a, b, c, d), # dsigmf(x, b1, c1, b2, c2) "gauss2mf": fuzz.gauss2mf(x, a, b, c, d), # gauss2mf(x, mean1, sigma1, mean2, sigma2) "gaussmf": fuzz.gaussmf(x, a, b), # gaussmf(x, mean, sigma) "gbellmf": fuzz.gbellmf(x, a, b, c), # gbellmf(x, a, b, c) "piecemf": fuzz.piecemf(x, abc), # piecemf(x, abc) "pimf": fuzz.pimf(x, a, b, c, d), # pimf(x, a, b, c, d) "psigmf": fuzz.psigmf(x, a, b, c, d), # psigmf(x, b1, c1, b2, c2) "sigmf": fuzz.sigmf(x, a, b), # sigmf(x, b, c) "smf": fuzz.smf(x, a, b), # smf(x, a, b) "trapmf": fuzz.trapmf(x, abcd), # trapmf(x, abcd) "zmf": fuzz.zmf(x, a, b), # zmf(x, a, b) }[mf]
def paramsToMF(params): """ Translate the piecewise params list of x_values to an MF function. Assumes a list of length: 1 - singleton MF 2 - gaussian MF function (mean, standard deviation) 3 - triangular MF function 4 - trapezoidal MF function """ c = 100.0 if len(params) == 1: #singleton c = 50 #special short MF for singleton xrange = [0.9*params[0], 1.1*params[0], 2*0.2*params[0]/c] x, y = singleton_to_fuzzy(params[0], xrange) if len(params) == 2: #gaussian MF #print "PARAMS:", params if params[1] == 0.0: v = 0.01*params[0] else: v = params[1] x = np.arange( params[0] - 6*v, params[0] + 6*v, (14.0*v/c) ) #use 6 sigmas y = fuzz.gaussmf(x, params[0], params[1]) elif len(params) == 3: #triangular MF if max(params) == min(params): prange = max(params) else: prange = max(params) - min(params) x = np.arange( min(params), max(params),prange/c) y = fuzz.trimf(x, params) elif len(params) == 4: #trapezoidal MF if max(params) == min(params): prange = max(params) else: prange = max(params) - min(params) x = np.arange( min(params), max(params),prange/c) y = fuzz.trapmf(x, params) return [np.asarray(x), np.asarray(y)] #create MF
def fuzzy_custom(height, growth, canopy): """ Perform fuzzy logic analysis on data. """ stress_data = np.empty_like(height) # Create inputs/outputs to the fuzzy control system h_var = ctrl.Antecedent(np.linspace(-0.01, 1.01, num=100), 'height') g_var = ctrl.Antecedent(np.linspace(-0.01, 1.01, num=100), 'growth') c_var = ctrl.Antecedent(np.linspace(-0.01, 1.01, num=100), 'canopy') stress_var = ctrl.Consequent(np.linspace(0, 1, num=100), 'stress') # Create membership functions for Antecedents and Consequents g_var.automf(3) c_var.automf(3) h_var['poor'] = fuzz.trapmf(np.linspace(-0.01, 1.01, num=100), [0, 0, 0.25, 0.5]) h_var['average'] = fuzz.trimf(np.linspace(-0.01, 1.01, num=100), [0.25, 0.5, 0.75]) h_var['good'] = fuzz.trapmf(np.linspace(-0.01, 1.01, num=100), [0.5, 0.75, 1, 1]) stress_var['low'] = fuzz.trapmf(np.linspace(-0.01, 1.01, num=100), [0, 0, 0.25, 0.5]) stress_var['med'] = fuzz.trimf(np.linspace(-0.01, 1.01, num=100), [0.25, 0.5, 0.75]) stress_var['high'] = fuzz.trapmf(np.linspace(-0.01, 1.01, num=100), [0.5, 0.75, 1, 1]) # Create basic rule-set grouping poor performance with high stress # Low height rules # GROWTH # H L M H # E ______ # I L| L L M # G M| L L L # H H| L L L # T rule_l1 = ctrl.Rule((h_var['poor'] & g_var['good'] & c_var['good']), stress_var['med']) rule_l2 = ctrl.Rule((h_var['poor'] & g_var['poor']), stress_var['high']) rule_l3 = ctrl.Rule((h_var['poor'] & g_var['average']), stress_var['high']) rule_l4 = ctrl.Rule((h_var['poor'] & c_var['poor']), stress_var['high']) rule_l5 = ctrl.Rule((h_var['poor'] & c_var['average']), stress_var['high']) # Med height rules # GROWTH # H L M H # E ______ # I L| M M H # G M| M M M # H H| L M M # T rule_m1 = ctrl.Rule((h_var['average'] & g_var['good'] & c_var['good']), stress_var['low']) rule_m2 = ctrl.Rule((h_var['average'] & g_var['poor'] & c_var['poor']), stress_var['high']) rule_m3 = ctrl.Rule((h_var['average'] & g_var['average']), stress_var['med']) rule_m4 = ctrl.Rule((h_var['average'] & c_var['average']), stress_var['med']) rule_m5 = ctrl.Rule((h_var['average'] & g_var['poor'] & c_var['good']), stress_var['med']) rule_m6 = ctrl.Rule((h_var['average'] & g_var['good'] & c_var['poor']), stress_var['med']) # High height rule # GROWTH # H L M H # E ______ # I L| H H H # G M| H H H # H H| H H H # T rule_h1 = ctrl.Rule((h_var['good']), stress_var['low']) # Create the fuzzy control system with the defined rule-set stress_sys = ctrl.ControlSystem([ rule_l1, rule_l2, rule_l3, rule_l4, rule_l5, rule_m1, rule_m2, rule_m3, rule_m4, rule_m5, rule_m6, rule_h1 ]) stress_sim = ctrl.ControlSystemSimulation(stress_sys) for i in range(height.shape[2]): # Split off layer from rest of data height_layer = height[:, :, i] growth_layer = growth[:, :, i] canopy_layer = canopy[:, :, i] # Normalize all of the data height_layer = np.divide(height_layer, np.amax(height_layer)) growth_layer = np.divide(growth_layer, np.amax(growth_layer)) canopy_layer = np.divide(canopy_layer, np.amax(canopy_layer)) # Input each data map into the simulation stress_sim.input['height'] = height_layer stress_sim.input['growth'] = growth_layer stress_sim.input['canopy'] = canopy_layer # Run the simulation and extract the output stress_sim.compute() stress_layer = stress_sim.output['stress'] # Smooth out local minimums and maximums stress_layer = img.grey_opening(stress_layer, structure=np.ones((3, 3))) stress_data[:, :, i] = stress_layer return stress_data
def __init__(self): #inputs self.catch = ctrl.Antecedent(np.arange(57, 68, 0.1), 'Catch') self.catch['Novice'] = fuzz.trapmf(self.catch.universe, [0,57, 57.5, 58]) self.catch['Intermediate'] = fuzz.gaussmf(self.catch.universe, 60.8, 1) self.catch['National'] = fuzz.gaussmf(self.catch.universe, 63.7, 1) self.catch['International'] = fuzz.trapmf(self.catch.universe, [66.1, 66.9, 68,68]) self.finish = ctrl.Antecedent(np.arange(36, 46, 0.1), 'Finish') self.finish['Novice'] = fuzz.trapmf(self.finish.universe, [0,36,37.2,38]) self.finish['Intermediate'] = fuzz.gaussmf(self.finish.universe, 39.9, 0.8) self.finish['National'] = fuzz.gaussmf(self.finish.universe, 42.2, 0.8) self.finish['International'] = fuzz.trapmf(self.finish.universe, [43.6, 45.4, 46, 46]) self.slip = ctrl.Antecedent(np.arange(2, 10, 0.1), 'Slip') self.slip['Novice'] = fuzz.trapmf(self.slip.universe, [7.7, 8.8, 10, 10]) self.slip['Intermediate'] = fuzz.gaussmf(self.slip.universe, 6.7, 0.6) self.slip['National'] = fuzz.gaussmf(self.slip.universe, 5.2, 0.6) self.slip['International'] = fuzz.trapmf(self.slip.universe, [2, 2, 3.5, 3.9]) self.wash = ctrl.Antecedent(np.arange(9, 30, 0.1), 'Wash') self.wash['Novice'] = fuzz.trapmf(self.wash.universe, [25.4, 28.1,30,30]) self.wash['Intermediate'] = fuzz.gaussmf(self.wash.universe, 23.5, 1.2) self.wash['National'] = fuzz.gaussmf(self.wash.universe, 20.2, 1.2) self.wash['International'] = fuzz.trapmf(self.wash.universe, [9,9, 15.5, 18.3]) self.length = ctrl.Antecedent(np.arange(95, 115, 0.1), 'Length') self.length['Novice'] = fuzz.trapmf(self.length.universe, [95,95, 97.1, 98.4]) self.length['Intermediate'] = fuzz.gaussmf(self.length.universe, 101.4, 1.4) self.length['National'] = fuzz.gaussmf(self.length.universe, 105.2, 1.4) self.length['International'] = fuzz.trapmf(self.length.universe, [107.7, 110, 115,115]) #output self.quality = ctrl.Consequent(np.arange(0, 101, 0.1), 'Quality') #setting membership functions self.quality['Novice'] = fuzz.gaussmf(self.quality.universe, 0, 10) self.quality['Intermediate'] = fuzz.gaussmf(self.quality.universe, 40, 8) self.quality['National'] = fuzz.gaussmf(self.quality.universe, 60, 8) self.quality['International'] = fuzz.gaussmf(self.quality.universe, 100, 10) #catch rule1 = ctrl.Rule(self.catch['Novice'], self.quality['Novice']) rule2 = ctrl.Rule(self.catch['Intermediate'], self.quality['Intermediate']) rule3 = ctrl.Rule(self.catch['National'], self.quality['National']) rule4 = ctrl.Rule(self.catch['International'], self.quality['International']) #finish rule5 = ctrl.Rule(self.finish['Novice'], self.quality['Novice']) rule6 = ctrl.Rule(self.finish['Intermediate'], self.quality['Intermediate']) rule7 = ctrl.Rule(self.finish['National'], self.quality['National']) rule8 = ctrl.Rule(self.finish['International'], self.quality['International']) #slip rule9 = ctrl.Rule(self.slip['Novice'], self.quality['Novice']) rule10 = ctrl.Rule(self.slip['Intermediate'], self.quality['Intermediate']) rule11 = ctrl.Rule(self.slip['National'], self.quality['National']) rule12 = ctrl.Rule(self.slip['International'], self.quality['International']) #wash rule13 = ctrl.Rule(self.wash['Novice'], self.quality['Novice']) rule14 = ctrl.Rule(self.wash['Intermediate'], self.quality['Intermediate']) rule15 = ctrl.Rule(self.wash['National'], self.quality['National']) rule16 = ctrl.Rule(self.wash['International'], self.quality['International']) #length rule17 = ctrl.Rule(self.length['Novice'], self.quality['Novice']) rule18 = ctrl.Rule(self.length['Intermediate'], self.quality['Intermediate']) rule19 = ctrl.Rule(self.length['National'], self.quality['National']) rule20 = ctrl.Rule(self.length['International'], self.quality['International']) rowingFIS_ctrl = ctrl.ControlSystem([ rule1, rule2, rule3, rule4, #catch rule5, rule6, rule7, rule8,#finish rule9, rule10, rule11, rule12,#slip rule13, rule14, rule15, rule16,#wash rule17, rule18, rule19, rule20#length ]) self.rowingFis = ctrl.ControlSystemSimulation(rowingFIS_ctrl)
def evaluate(x, X, y, X_test, y_test, rated, mfs, rules, p, resampling, num_samples=200, n_ratio=0.6): # print(solution.variables) i = 0 for var in sorted(mfs.keys()): for mf in range(len(mfs[var])): if mfs[var][mf]['type'] == 'gauss': mfs[var][mf]['param'] = x[i:i + 2] mfs[var][mf]['func'] = fuzz.gaussmf( mfs[var][mf]['universe'], mfs[var][mf]['param'][0], np.abs(mfs[var][mf]['param'][1])) i += 2 elif mfs[var][mf]['type'] == 'trap': mfs[var][mf]['param'] = sorted(x[i:i + 4]) mfs[var][mf]['func'] = fuzz.trapmf(mfs[var][mf]['universe'], mfs[var][mf]['param']) i += 4 for r in sorted(rules.keys()): for i in range(len(rules[r])): ind = int(re.sub("\D", "", rules[r][i]['name'])) rules[r][i]['param'] = mfs[rules[r][i]['var_name']][ind]['param'] rules[r][i]['func'] = mfs[rules[r][i]['var_name']][ind]['func'] activations = pd.DataFrame( index=X.index, columns=['rule.' + str(i) for i in range(len(rules))]) for rule in sorted(rules.keys()): act = [] for mf in rules[rule]: act.append( fuzz.interp_membership(mf['universe'], mf['func'], X[mf['var_name']])) activations[rule] = np.power(np.prod(np.array(act), axis=0), 1 / p) lin_models = dict() for rule in activations.columns: indices = activations[rule].index[activations[rule] >= 0.01].tolist() if len(indices) > num_samples and len(indices) < n_ratio * X.shape[0]: X1 = X.loc[indices].values y1 = y.loc[indices].values # if resampling: # if X1.shape[0] < 300: # X1, y1 = resampling_fun(X1,y1) lin_models[rule] = LinearRegression().fit(X1, y1.ravel()) elif len(indices) > 0: lin_models[rule] = 'null' else: lin_models[rule] = None for rule in sorted(rules.keys()): indices = activations[rule].index[activations[rule] >= 0.01].tolist() if len(indices) <= num_samples and len(indices) < n_ratio * X.shape[ 0] and len(indices) < n_ratio * X.shape[0]: del rules[rule] del lin_models[rule] activations_test = pd.DataFrame( index=X_test.index, columns=['rule.' + str(i) for i in sorted(rules.keys())]) for rule in sorted(rules.keys()): act = [] for mf in rules[rule]: act.append( fuzz.interp_membership(mf['universe'], mf['func'], X_test[mf['var_name']])) activations_test[rule] = np.power(np.prod(np.array(act), axis=0), 1 / p) preds = pd.DataFrame(index=X_test.index, columns=sorted(rules.keys())) for rule in sorted(rules.keys()): indices = activations_test[rule].index[ activations_test[rule] >= 0.01].tolist() if len(indices) != 0: X1 = X_test.loc[indices].values if (lin_models[rule] != 'null' and not lin_models[rule] is None): preds.loc[indices, rule] = lin_models[rule].predict(X1).ravel() elif lin_models[rule] == 'null': preds.loc[indices, rule] = 1e+15 pred = preds.mean(axis=1) pred[pred.isnull()] = 1e+15 # pred.name='target' # pred=pred.to_frame() err = (pred.values.ravel() - y_test.values.ravel()) / rated objectives = [np.sum(np.square(err)), np.mean(np.abs(err))] return objectives
def buildFuzzySystem(showDescription=False): """ =========================================================================== Build Fuzzy Sistem for variable: cnxs: network connections =========================================================================== **Args**: showDescription: (boolean) **Returns**: None """ #========================================================================== # Set labels of inputs and outputs #========================================================================== in1_max = 10000 var_in1_label = 'net_io_rate_in' var_out_label = 'out' logger.info("buildFuzzySystem:" + var_in1_label) #========================================================================== # Set numerical range of inputs and outputs #========================================================================== var_in1_universe = np.arange(0, in1_max, in1_max / 1000) 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['low'] = fuzz.trimf(var_in1.universe, [0, 0, in1_max * 0.1]) var_in1['average'] = fuzz.trapmf( var_in1.universe, [0, 0.1 * in1_max, 0.3 * in1_max, 0.5 * in1_max]) var_in1['high'] = fuzz.smf(var_in1.universe, 0.3 * in1_max, 0.5 * in1_max) var_out.automf(number=3, variable_type='quant') #========================================================================== # Set fuzzy rules #========================================================================== rule1 = ctrl.Rule(var_in1['high'], var_out['high']) rule2 = ctrl.Rule(var_in1['average'], var_out['average']) rule3 = ctrl.Rule(var_in1['low'], var_out['low']) #========================================================================== # Build fuzzy control system and simulation #========================================================================== var_ctrl = ctrl.ControlSystem([rule1, rule2, rule3]) 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['average'].mf, label='average') 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
# In[3]: x_korban = np.arange(0, 55,1) x_infrastruktur = np.arange(0, 55,1) x_tim = np.arange(0, 25, 1) # In[ ]: korban_minor = fuzz.trapmf(x_korban, [0,0,5,20]) korban_masif = fuzz.trapmf(x_korban, [10,40,60,60]) infrastruktur_minor = fuzz.trapmf(x_infrastruktur, [0,0,5,20]) infrastruktur_masif = fuzz.trapmf(x_infrastruktur, [15,45,60,60]) tim_sedikit = fuzz.trapmf(x_tim, [0,0,5,15]) tim_banyak = fuzz.trapmf(x_tim, [10,20,30,30]) # In[14]: angka = [] for x in sys.argv[1] : x = sys.argv[1].split(",")
matplotlib.use("TkAgg") import matplotlib.pyplot as plot # Variáveis do Problema velocidade = ctrl.Antecedent(np.arange(0, 101, 1), "velocidade") limite = ctrl.Antecedent(np.arange(0, 101, 1), "limite") multa = ctrl.Consequent(np.arange(0, 1001, 1), "multa") velocidade.automf(names=["baixa", "media", "alta"]) # Cria funções de pertinência usando tipos variados limite["baixo"] = fuzz.trimf(limite.universe, [0, 0, 50]) limite["medio"] = fuzz.gaussmf(limite.universe, 50, 5) limite["alto"] = fuzz.gaussmf(limite.universe, 100, 20) multa["baixa"] = fuzz.trapmf(multa.universe, [0, 0, 200, 500]) multa["media"] = fuzz.trimf(multa.universe, [300, 500, 700]) multa["alta"] = fuzz.trimf(multa.universe, [500, 1000, 1000]) # Regras de decisões rule1 = ctrl.Rule(limite["baixo"] & velocidade["alta"], multa["alta"]) rule2 = ctrl.Rule(limite["medio"] & velocidade["alta"], multa["media"]) rule3 = ctrl.Rule(limite["alto"] & velocidade["alta"], multa["baixa"]) rule4 = ctrl.Rule(limite["baixo"] & velocidade["media"], multa["media"]) rule5 = ctrl.Rule(limite["medio"] & velocidade["media"], multa["baixa"]) rule6 = ctrl.Rule(limite["baixo"] & velocidade["baixa"], multa["baixa"]) rule7 = ctrl.Rule(limite["baixo"] & velocidade["media"], multa["media"]) rule8 = ctrl.Rule(limite["baixo"] & velocidade["alta"], multa["alta"]) class Aplicacao:
import numpy as np import skfuzzy as fuzz from skfuzzy import control as ctrl import matplotlib.pyplot as plt import time # Antecedents objects distancesAntecedents = [] for i in range(8): distancesAntecedents.append( ctrl.Antecedent(np.arange(0, 5, 0.01), 'distance_' + str(i))) vel_left = ctrl.Consequent(np.arange(-5, 5, 0.1), 'vel_left') vel_right = ctrl.Consequent(np.arange(-5, 5, 0.1), 'vel_right') for i in range(8): distancesAntecedents[i]["perto"] = fuzz.trapmf( distancesAntecedents[i].universe, [0, 0, 0.8, 2.5]) distancesAntecedents[i]["longe"] = fuzz.trapmf( distancesAntecedents[i].universe, [0.8, 2.5, 6, 6]) vel_left['pos_fast'] = fuzz.trimf(vel_left.universe, [1, 5, 5]) vel_left['pos_slow'] = fuzz.trimf(vel_left.universe, [0, 1.5, 1.5]) vel_left['neg_fast'] = fuzz.trimf(vel_left.universe, [-5, -5, -1]) vel_left['neg_slow'] = fuzz.trimf(vel_left.universe, [-1.5, -1.5, 0]) vel_right['pos_fast'] = fuzz.trimf(vel_left.universe, [1, 4.8, 4.8]) vel_right['pos_slow'] = fuzz.trimf(vel_left.universe, [0, 1.3, 1.3]) vel_right['neg_fast'] = fuzz.trimf(vel_left.universe, [-5, -5, -1]) vel_right['neg_slow'] = fuzz.trimf(vel_left.universe, [-1.5, -1.5, 0]) rule1 = ctrl.Rule( distancesAntecedents[3]['perto'] | distancesAntecedents[4]['perto'], vel_left['pos_fast'])
parser.add_argument("--output_csv", default='./output_part1.csv', type=str, help='Input csv file path') args = parser.parse_args() # Define universe price = np.arange(0, 31, 1) distance = np.arange(0, 21, 1) rating = np.arange(0, 6, 1) going = 1 not_going = 0 label = np.arange(0, 1.01, 0.01) # Define membership function cheap = fuzz.trapmf(price, [0, 0, 7, 10]) medium_price = fuzz.trimf(price, [7, 12, 18]) expensive = fuzz.trapmf(price, [14, 25, 30, 30]) close = fuzz.trapmf(distance, [0, 0, 5, 7]) medium_distance = fuzz.trimf(distance, [5, 10, 15]) far = fuzz.trapmf(distance, [10, 15, 20, 20]) bad = fuzz.trapmf(rating, [0, 0, 2, 3]) moderate = fuzz.trimf(rating, [2, 3, 4]) good = fuzz.trapmf(rating, [3, 4, 5, 5]) not_go = fuzz.trimf(label, [0, 0, 1.0]) will_go = fuzz.trimf(label, [0, 1.0, 1.0]) # Plot MF graph
def funcionGrande(tamanio): grande = fuzz.trapmf(tamanio.universe,[250,350,450,450]) return grande
def funcionMediano(tamanio): mediano = fuzz.trapmf(tamanio.universe,[90,200,250,350]) return mediano
def funcionPequenio(tamanio): pequenio = fuzz.trapmf(tamanio.universe,[0,0,90,200]) return pequenio
import skfuzzy as fuzz import matplotlib.pyplot as plt # input variables input_participants = 120 input_available_slots = 15 input_test_difficulty = 5 # create universes participants = np.arange(50, 201, 1) available_slots = np.arange(0, 21, 1) test_difficulty = np.arange(0, 11, 1) acceptance_probability = np.arange(0, 101, 1) # create membership functions participants_low = fuzz.trapmf(participants, [50, 50, 75, 110]) participants_medium = fuzz.trimf(participants, [90, 120, 150]) participants_high = fuzz.trapmf(participants, [130, 160, 200, 200]) available_slots_low = fuzz.trapmf(available_slots, [0, 0, 2, 8]) available_slots_medium = fuzz.trapmf(available_slots, [4, 8, 12, 16]) available_slots_high = fuzz.trapmf(available_slots, [13, 17, 20, 20]) test_difficulty_low = fuzz.trapmf(test_difficulty, [0, 0, 3, 5]) test_difficulty_medium = fuzz.trimf(test_difficulty, [4, 6, 8]) test_difficulty_high = fuzz.trapmf(test_difficulty, [7, 9, 10, 10]) acceptance_probability_low = fuzz.trimf(acceptance_probability, [0, 0, 50]) acceptance_probability_medium = fuzz.trimf(acceptance_probability, [10, 50, 90]) acceptance_probability_high = fuzz.trimf(acceptance_probability, [50, 100, 100])
def build_fuzzy_variables(): # Sparse universe makes calculations faster, without sacrifice accuracy. # Only the critical points are included here; making it higher resolution is # unnecessary. universe_theta = np.array([-0.15, -0.1, -0.05, 0, 0.05, 0.1]) universe_vtheta= np.array([-0.125, -0.075, -0.025, 0.025, 0.075, 0.125]) universe_phi = np.array([-0.2, -0.1, -0.05, 0.05, 0.1, 0.2]) universe_vphi = np.array([-0.125, -0.075, -0.025, 0.025, 0.075, 0.125]) universe_output= np.arange(-1, 1.1, 1/6) # Create the three fuzzy variables - four inputs, one output theta = ctrl.Antecedent(universe_theta , 'theta') vtheta= ctrl.Antecedent(universe_vtheta, 'vtheta') phi = ctrl.Antecedent(universe_phi , 'phi') vphi = ctrl.Antecedent(universe_vphi , 'vphi') output= ctrl.Consequent(universe_output, 'output') # Set membership function # fuzz.trapmf(support_x,[0,0,20,30]) sup = theta.universe theta['low'] = fuzz.trapmf(theta.universe, [sup[0], sup[0], sup[1], sup[2]]) theta['normal'] = fuzz.trapmf(theta.universe, [sup[1], sup[2], sup[3], sup[4]]) theta['high'] = fuzz.trapmf(theta.universe, [sup[3], sup[4], sup[5], sup[5]]) sup = vtheta.universe vtheta['falling'] = fuzz.trapmf(vtheta.universe, [sup[0], sup[0], sup[1], sup[2]]) vtheta['stable'] = fuzz.trapmf(vtheta.universe, [sup[1], sup[2], sup[3], sup[4]]) vtheta['rising'] = fuzz.trapmf(vtheta.universe, [sup[3], sup[4], sup[5], sup[5]]) sup = phi.universe phi['left'] = fuzz.trapmf(phi.universe, [sup[0], sup[0], sup[1], sup[2]]) phi['center'] = fuzz.trapmf(phi.universe, [sup[1], sup[2], sup[3], sup[4]]) phi['right'] = fuzz.trapmf(phi.universe, [sup[3], sup[4], sup[5], sup[5]]) sup = vphi.universe vphi['goleft'] = fuzz.trapmf(vphi.universe, [sup[0], sup[0], sup[1], sup[2]]) vphi['stable'] = fuzz.trapmf(vphi.universe, [sup[1], sup[2], sup[3], sup[4]]) vphi['goright'] = fuzz.trapmf(vphi.universe, [sup[3], sup[4], sup[5], sup[5]]) output.automf(names=['lefthard','left','leftslow','hold','rightslow','right','righthard']) return theta, vtheta, phi, vphi, output
Fuzzy logic calculations are excellent tools, but to use them the fuzzy result must be converted back into a single number. This is known as defuzzification. There are several possible methods for defuzzification, exposed via `skfuzzy.defuzz`. """ import numpy as np import matplotlib.pyplot as plt import skfuzzy as fuzz # Generate trapezoidal membership function on range [0, 1] x = np.arange(0, 5.05, 0.1) mfx = fuzz.trapmf(x, [2, 2.5, 3, 4.5]) # Defuzzify this membership function five ways defuzz_centroid = fuzz.defuzz(x, mfx, 'centroid') # Same as skfuzzy.centroid defuzz_bisector = fuzz.defuzz(x, mfx, 'bisector') defuzz_mom = fuzz.defuzz(x, mfx, 'mom') defuzz_som = fuzz.defuzz(x, mfx, 'som') defuzz_lom = fuzz.defuzz(x, mfx, 'lom') # Collect info for vertical lines labels = ['centroid', 'bisector', 'mean of maximum', 'min of maximum', 'max of maximum'] xvals = [defuzz_centroid, defuzz_bisector, defuzz_mom, defuzz_som,
import Node611 import excel import mcpras import time #Fuzzy Controller Vrefd = ctrl.Consequent(np.arange(-2, 2, 0.1), 'Vrefd') dpdv = ctrl.Antecedent(np.arange(-200, 200, 0.01), 'dpdv') Vdif = ctrl.Antecedent(np.arange(-2, 2, 0.1), 'Vdif') #Membership functions #Pdif dpdv['N'] = fuzz.trapmf(dpdv.universe, [-300, -2, -0.2, -0.01]) dpdv['P'] = fuzz.trapmf(dpdv.universe, [0.01, 0.2, 2, 300]) dpdv['Z'] = fuzz.trimf(dpdv.universe, [-0.01, 0, 0.01]) #Vdif Vdif['N'] = fuzz.trimf(Vdif.universe, [-0.3, -0.2, -0.1]) Vdif['P'] = fuzz.trimf(Vdif.universe, [0.1, 0.2, 0.3]) Vdif['Z'] = fuzz.trimf(Vdif.universe, [-0.01, 0, 0.01]) #Vref Vrefd['N'] = fuzz.trimf(Vrefd.universe, [-0.3, -0.2, -0.1]) Vrefd['P'] = fuzz.trimf(Vrefd.universe, [0.1, 0.2, 0.3]) Vrefd['Z'] = fuzz.trimf(Vrefd.universe, [-0.01, 0, 0.01])
def init_fuzzy_logic(self): xa = ctrl.Antecedent(np.arange(-0.5, 9, 0.01), 'xa') ya = ctrl.Antecedent(np.arange(-0.3, 9, 0.01), 'ya') angle = ctrl.Antecedent(np.arange(-44.6, 121, 0.01), 'angle') steering = ctrl.Consequent(np.arange(-35, 37.38, 0.01), 'steering') # Custom membership functions xa['S'] = fuzz.trimf(xa.universe, [-0.23, 0.20, 0.57]) xa['B'] = fuzz.trimf(xa.universe, [0.4, 0.7, 1]) xa['P'] = fuzz.trimf(xa.universe, [0.93, 1.47, 1.92]) xa['PB'] = fuzz.trapmf(xa.universe, [1.74, 2.14, 9, 9]) # xa.view() # plt.show() ya['S'] = fuzz.trimf(ya.universe, [-0.3, 0.4, 1.21]) ya['B'] = fuzz.trimf(ya.universe, [0.94, 1.65, 2.24]) ya['PM'] = fuzz.trimf(ya.universe, [2.18, 2.52, 2.75]) ya['PB'] = fuzz.trapmf(ya.universe, [2.75, 3.23, 9, 9]) # ya.view() # plt.show() angle['N'] = fuzz.trapmf(angle.universe, [-44.6, -27.6, -17.6, -2.3]) angle['Z'] = fuzz.trimf(angle.universe, [-4.46, 0, 2.03]) angle['P'] = fuzz.trapmf(angle.universe, [0.11, 7.37, 56.3, 91]) angle['PM'] = fuzz.trimf(angle.universe, [88, 90, 93.2]) angle['PB'] = fuzz.trapmf(angle.universe, [92.45, 97, 120, 120]) # angle.view() # plt.show() steering['NB'] = fuzz.trimf(steering.universe, [-35, -32.14, -29.15]) steering['NM'] = fuzz.trimf(steering.universe, [-29.77, -20.43, -11.09]) steering['N'] = fuzz.trimf(steering.universe, [-20.43, -11.71, -2.87]) steering['Z'] = fuzz.trimf(steering.universe, [-3.85, 0, 4.12]) steering['P'] = fuzz.trimf(steering.universe, [2.87, 11.71, 20.43]) steering['PM'] = fuzz.trimf(steering.universe, [4.98, 14.95, 24.91]) steering['PB'] = fuzz.trapmf(steering.universe, [23.67, 26.16, 37.37, 37.37]) # steering.view() # plt.show() # When xa is S rule1 = ctrl.Rule(xa['S'] & ya['S'] & angle['P'], steering['NB']) rule2 = ctrl.Rule(xa['S'] & ya['B'] & angle['P'], steering['NB']) rule21 = ctrl.Rule(xa['S'] & ya['B'] & angle['PM'], steering['Z']) rule22 = ctrl.Rule(xa['S'] & ya['B'] & angle['PB'], steering['P']) rule3 = ctrl.Rule(xa['S'] & ya['S'] & angle['PM'], steering['Z']) # When xa is B rule4 = ctrl.Rule(xa['B'] & ya['B'] & angle['P'], steering['NB']) rule41 = ctrl.Rule(xa['B'] & ya['S'] & angle['PM'], steering['Z']) rule42 = ctrl.Rule(xa['B'] & ya['B'] & angle['PM'], steering['Z']) # When xa is P rule5 = ctrl.Rule(xa['P'] & ya['B'] & angle['Z'], steering['NM']) rule6 = ctrl.Rule(xa['P'] & ya['B'] & angle['P'], steering['NM']) # When xa is PB rule7 = ctrl.Rule(xa['PB'] & ya['B'] & angle['N'], steering['NB']) rule8 = ctrl.Rule(xa['PB'] & ya['B'] & angle['Z'], steering['Z']) rule9 = ctrl.Rule(xa['PB'] & ya['B'] & angle['P'], steering['PB']) # rule1.view() # plt.show() steering_ctrl = ctrl.ControlSystem([ rule1, rule2, rule21, rule3, rule4, rule41, rule42, rule5, rule6, rule7, rule8, rule9 ]) return ctrl.ControlSystemSimulation(steering_ctrl)
def __init__(self, abcd): self.x_points = np.arange(abcd[0], abcd[3]+1,1) self.fct = fuzz.trapmf(self.x_points, abcd)
# Delta para aumento do espaço de entrada Dc = .00001 Dl = .00001 # Definindo espaço de entrada comprimento = ctrl.Antecedent(np.arange(minc - Dc, maxc + Dc, .00001), 'comprimento') largura = ctrl.Antecedent(np.arange(minl - Dl, maxl + Dl, .00001), 'largura') # Denifinindo espaço de saída # especie = ctrl.Consequent(np.arange(0, 2.01, 0.01),'especie') especie = ctrl.Consequent(np.arange(0, 3.01, 0.01), 'especie') # Definindo conjuntos # Comprimento Baixo(CB), Médio(CM) e Alto(CA) comprimento['CB'] = fuzz.trapmf(comprimento.universe, [minc, minc, mediaCe1, mediaCe2]) comprimento['CM'] = fuzz.trimf(comprimento.universe, [mediaCe1, mediaCe2, mediaCe3]) comprimento['CA'] = fuzz.trapmf(comprimento.universe, [mediaCe2, mediaCe3, maxc, maxc]) # Largura Baixa(LB), Média(LM) e Alta(LA) largura['LB'] = fuzz.trapmf(largura.universe, [minl, minl, mediaLe1, mediaLe2]) largura['LM'] = fuzz.trimf(largura.universe, [mediaLe1, mediaLe2, mediaLe3]) largura['LA'] = fuzz.trapmf(largura.universe, [mediaLe2, mediaLe3, maxl, maxl]) # Definindo saída como Espécie 1 (E1), 2 (E2) e 3 (E3) especie['E1'] = fuzz.trimf(especie.universe, [0, 0, 1]) especie['E2'] = fuzz.trimf(especie.universe, [1, 1.5, 2]) especie['E3'] = fuzz.trimf(especie.universe, [2, 3, 3])
sensor_mp = [0, 0, 0, 20] sensor_p = [0, 20, 90, 100] sensor_l = [100, 150, 200, 300] sensor_ml = [200, 300, 500, 500] # Actuators trampf points actuator_l = [0, 0, 0, 50] actuator_m = [50, 70, 110, 130] actuator_r = [100, 150, 200, 200] ''' f_s2['mp'] = fuzz.trapmf(f_s2.universe, sensor_mp) f_s2['p'] = fuzz.trapmf(f_s2.universe, sensor_p) f_s2['l'] = fuzz.trapmf(f_s2.universe, sensor_l) f_s2['ml'] = fuzz.trapmf(f_s2.universe, sensor_ml) ''' f_s4['mp'] = fuzz.trapmf(f_s4.universe, sensor_mp) f_s4['p'] = fuzz.trapmf(f_s4.universe, sensor_p) f_s4['l'] = fuzz.trapmf(f_s4.universe, sensor_l) f_s4['ml'] = fuzz.trapmf(f_s4.universe, sensor_ml) ''' f_s5['mp'] = fuzz.trapmf(f_s5.universe, sensor_mp) f_s5['p'] = fuzz.trapmf(f_s5.universe, sensor_p) f_s5['l'] = fuzz.trapmf(f_s5.universe, sensor_l) f_s5['ml'] = fuzz.trapmf(f_s5.universe, sensor_ml) f_s7['mp'] = fuzz.trapmf(f_s7.universe, sensor_mp) f_s7['p'] = fuzz.trapmf(f_s7.universe, sensor_p) f_s7['l'] = fuzz.trapmf(f_s7.universe, sensor_l) f_s7['ml'] = fuzz.trapmf(f_s7.universe, sensor_ml) f_s10['mp'] = fuzz.trapmf(f_s10.universe, sensor_mp)
#calculate overlap overlap = 100.*float(min(max(outRange), max(alt[7])) - max(min(outRange), min(alt[7])))/ \ max( max(outRange)-min(outRange) , max(alt[7])-min(alt[7]) ) print alt[0], overlap, '% overlap' ax1.bar(outRange[0], 0.3, width=outRange[1]-outRange[0], bottom=ps_inputs.index(alt)+0.7, color='r') ax1.bar(alt[7][0], 0.3, width=alt[7][1]-alt[7][0], bottom=ps_inputs.index(alt)+1.0, color='b') ax1.text(max(max(outRange),max(alt[7]))+0.5, ps_inputs.index(alt)+0.9, str(round(overlap,1))+'%', fontsize=10) #plot actual outputs i = ps_inputs.index(alt) ax2[(i-(i%2))/2, i%2].plot(output[0], output[1], '-r') exp_x = np.arange(0.9*min(alt[7]), 1.1*max(alt[7]), (max(alt[7])-min(alt[7]))/50.) exp_y = fuzz.trapmf(exp_x, [min(alt[7]), min(alt[7]), max(alt[7]), max(alt[7])]) ax2[(i-(i%2))/2, i%2].plot(exp_x, exp_y, '-b') ax1.set_ylim([0,11]) ax1.set_xlim([5,25]) ax1.yaxis.grid(True) ax1.set_yticks(range(1,11)) ax1.set_yticklabels([alt[0] for alt in ps_inputs]) ax1.set_xlabel('System L/D') fontP = FontProperties() fontP.set_size('medium') ax1.legend(['Fuzzy System Output', 'Expert System Evaluations'], bbox_to_anchor=(1.0, 1.06), prop=fontP)
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') # Self Test locally speeds = np.arange(60,150,0.1) y = np.zeros_like(speeds) for i in range(len(speeds)): y[i] = throttle_command(speeds[i]) # Input membership functions too_slow = fuzz.trapmf(speeds,[60,60,80,85]) slow = fuzz.trimf(speeds,[83,90,97]) cruise = fuzz.trimf(speeds,[95,100,105]) fast = fuzz.trimf(speeds,[103,110,117]) too_fast = fuzz.trapmf(speeds,[115,120,150,150]) plt.plot(speeds,y,speeds,too_slow,speeds,slow,speeds,cruise,speeds,fast,speeds,too_fast) plt.xlabel('Airspeed (KIAS)') plt.ylabel('Throttle Command/Speed Membership Functions') plt.title('Throttle Commands vs. Airspeeds') plt.legend(('Throttle Commands','Too Slow','Slow','Cruise','Fast','Too Fast'),bbox_to_anchor=(1.05, 1),loc=2, borderaxespad=0.) plt.show() ### Test with x-plane
def create_mfs(self, model_mfs, type_mf, num_mf, var_range, var_name): mfs = [] if type_mf in { 'hdd_h2', 'temp_max', 'flux', 'wind', 'temp', 'Temp', 'load', 'power' }: mean = np.linspace(var_range[0], var_range[1], num=num_mf) std = var_range[1] / num_mf for i in range(num_mf): mfs.append({ 'name': 'mf_' + type_mf + str(i), 'var_name': var_name, 'type': 'gauss', 'param': [mean[i], 1.25 * std], 'universe': np.arange(var_range[0] - std - .01, var_range[1] + std + .01, .001), 'func': fuzz.gaussmf( np.arange(var_range[0] - std - .01, var_range[1] + std + .01, .001), mean[i], std) }) elif type_mf in { 'sp_index', 'dayweek', 'cloud', 'hour', 'month', 'direction', 'sp_days' }: mean = np.linspace(var_range[0], var_range[1], num=num_mf) std = var_range[1] / num_mf std1 = var_range[1] / (2 * num_mf) for i in range(num_mf): param = [ mean[i] - 1.5 * std, mean[i] - 1.25 * std1, mean[i] + 1.25 * std1, mean[i] + 1.5 * std ] mfs.append({ 'name': 'mf_' + type_mf + str(i), 'var_name': var_name, 'type': 'trap', 'param': param, 'universe': np.arange(var_range[0] - .01 - std, var_range[1] + std + .01, .001), 'func': fuzz.trapmf( np.arange( var_range[0] - .01 - std, var_range[1] + std + .01, .001, ), param) }) else: raise NameError('MF type not recognize') model_mfs[var_name] = mfs return model_mfs
for i in range(len(y)): if i <= maxX: y2.append(maxY) #extend function towards min (left) else: y2.append(y[i]) if direction is 'min': minX = min([i for i in range(len(yMs)) if yMs[i] == 1]) y2 = [] for i in range(len(y)): if i >= minX: y2.append(maxY) #extend function towards max (right) else: y2.append(y[i]) if plot: ax.plot(x,y2, '--c') ax.plot([goal, goal], [0.,1.], ':k') ax.set_ylim([0.0,1.01]) plt.show() d = fuzz.interp_membership(x,y2,goal) return d except: e = sys.exc_info()[0] print "Error calculating fuzzy POS:", e return 0.0 ################################################################################ if __name__=="__main__": Ax = np.arange(1,9,0.1) Ay = fuzz.trapmf(Ax, [4,5,6,7]) POS = fuzzyPOS(Ax,Ay,4.5,direction='min', plot=True) print "POSmin:", POS POS = fuzzyPOS(Ax,Ay,6.5, plot=True) print "POSmax:", POS
def cantidadesAguaLecheChocolateCafeTiempo(): agua = ctrl.Consequent( [0, 30, 60, 90, 120, 150, 200, 250, 300, 350, 400, 450], 'agua') #consecuente agua agua['poca'] = fuzz.trapmf(agua.universe, [0, 0, 90, 200]) agua['media'] = fuzz.trapmf(agua.universe, [90, 200, 250, 350]) agua['mucha'] = fuzz.trapmf(agua.universe, [250, 350, 450, 450]) cafe = ctrl.Consequent(np.arange(0, 30, 1), 'cafe') #consecuente cafe cafe['poca'] = fuzz.trapmf(cafe.universe, [0, 0, 7, 15]) cafe['media'] = fuzz.trimf(cafe.universe, [10, 15, 20]) cafe['mucha'] = fuzz.trapmf(cafe.universe, [15, 22, 30, 30]) leche = ctrl.Consequent(np.arange(0, 50, 1), 'leche') #consecuente leche leche['poca'] = fuzz.trapmf(leche.universe, [0, 0, 13, 25]) leche['media'] = fuzz.trimf(leche.universe, [13, 25, 38]) leche['mucha'] = fuzz.trapmf(leche.universe, [25, 38, 50, 50]) chocolate = ctrl.Consequent(np.arange(0, 80, 1), 'chocolate') #consecuente chocolate chocolate['poca'] = fuzz.trapmf(chocolate.universe, [0, 0, 20, 40]) chocolate['media'] = fuzz.trimf(chocolate.universe, [20, 40, 60]) chocolate['mucha'] = fuzz.trapmf(chocolate.universe, [40, 60, 80, 80]) tiempo = ctrl.Consequent(np.arange(0, 34, 1), 'tiempo') #consecuente tiempo tiempo['poca'] = fuzz.trapmf(tiempo.universe, [0, 0, 8, 17]) tiempo['media'] = fuzz.trimf(tiempo.universe, [8, 17, 25]) tiempo['mucha'] = fuzz.trapmf(tiempo.universe, [17, 25, 34, 34]) #se grafican todos los consecuentes graficar.graficarGrid( agua.universe, cafe.universe, leche.universe, chocolate.universe, tiempo.universe, [agua['poca'].mf, agua['media'].mf, agua['mucha'].mf], [cafe["poca"].mf, cafe["media"].mf, cafe["mucha"].mf], [leche["poca"].mf, leche["media"].mf, leche["mucha"].mf], [chocolate["poca"].mf, chocolate["media"].mf, chocolate["mucha"].mf], [tiempo["poca"].mf, tiempo["media"].mf, tiempo["mucha"].mf], ["Poca", "Media", "Mucha"], [ "Agua [ml]", "Cafe [grs]", "Leche [grs]", "Chocolate [grs]", "Tiempo [s]" ], ["Pertenencia", "Pertenencia", "Pertenencia", "Pertenencia"], "Cantidades vs Pertenencia") return agua, cafe, leche, chocolate, tiempo
def evaluate(self, x, X, y, X_test, y_test, rated, mfs, rules, p, resampling): # print(solution.variables) i = 0 for var in sorted(mfs.keys()): for mf in range(len(mfs[var])): if mfs[var][mf]['type'] == 'gauss': mfs[var][mf]['param'] = x[i:i + 2] mfs[var][mf]['func'] = fuzz.gaussmf( mfs[var][mf]['universe'], mfs[var][mf]['param'][0], np.abs(mfs[var][mf]['param'][1])) i += 2 elif mfs[var][mf]['type'] == 'trap': mfs[var][mf]['param'] = sorted(x[i:i + 4]) mfs[var][mf]['func'] = fuzz.trapmf( mfs[var][mf]['universe'], mfs[var][mf]['param']) i += 4 for r in sorted(rules.keys()): for i in range(len(rules[r])): ind = int(re.sub("\D", "", rules[r][i]['name'])) rules[r][i]['param'] = mfs[rules[r][i] ['var_name']][ind]['param'] rules[r][i]['func'] = mfs[rules[r][i]['var_name']][ind]['func'] activations = pd.DataFrame( index=X.index, columns=[rule for rule in sorted(rules.keys())]) for rule in sorted(rules.keys()): act = [] for mf in rules[rule]: act.append( fuzz.interp_membership(mf['universe'], mf['func'], X[mf['var_name']])) activations[rule] = np.power(np.prod(np.array(act), axis=0), 1 / p) lin_models = dict() remove_null_rules = [] for rule in sorted(activations.columns): indices = activations[rule].index[ activations[rule] >= 0.01].tolist() if len(indices) > self.num_samples and len( indices) < self.n_ratio * X.shape[0]: X1 = X.loc[indices].values y1 = y.loc[indices].values lin_models[rule] = LinearRegression().fit(X1, y1.ravel()) elif len(indices) > 0: lin_models[rule] = 'null' remove_null_rules.append(rule) else: lin_models[rule] = None remove_null_rules.append(rule) total = 0 for rule in sorted(rules.keys()): indices = activations[rule].index[ activations[rule] >= 0.01].tolist() act = activations.loc[indices].copy(deep=True) act = act.drop(columns=[rule]) if len(indices) <= self.num_samples and len( indices) < self.n_ratio * X.shape[0] and not act.isnull( ).all(axis=1).any(): del rules[rule] del lin_models[rule] else: print(len(indices)) self.logger.info("Number of samples of rule %s is %s", rule, len(indices)) total += len(indices) print(total) self.logger.info("Number of samples of dataset with %s is %s", X.shape[0], total) activations_test = pd.DataFrame( index=X_test.index, columns=[rule for rule in sorted(rules.keys())]) for rule in sorted(rules.keys()): act = [] for mf in rules[rule]: act.append( fuzz.interp_membership(mf['universe'], mf['func'], X_test[mf['var_name']])) activations_test[rule] = np.power(np.prod(np.array(act), axis=0), 1 / p) preds = pd.DataFrame(index=X_test.index, columns=sorted(lin_models.keys())) for rule in sorted(rules.keys()): indices = activations_test[rule].index[ activations_test[rule] >= 0.01].tolist() if len(indices) != 0: X1 = X_test.loc[indices].values y1 = y_test.loc[indices].values if (lin_models[rule] != 'null' and not lin_models[rule] is None): preds.loc[indices, rule] = lin_models[rule].predict(X1).ravel() elif lin_models[rule] == 'null': preds.loc[indices, rule] = 1e+15 if isinstance(rated, float) or isinstance(rated, int): err = (preds.loc[indices, rule].values.ravel() - y1.ravel()) / rated else: err = (preds.loc[indices, rule].values.ravel() - y1.ravel()) / y1.ravel() self.logger.info("MAE of rule %s is %s", rule, np.mean(np.abs(err))) pred = preds.mean(axis=1) pred[pred.isnull()] = 1e+15 # pred.name='target' # pred=pred.to_frame() err = (pred.values.ravel() - y_test.values.ravel()) / rated self.objectives = [np.sum(np.square(err)), np.mean(np.abs(err))] self.rules = rules self.mfs = mfs fmodel = dict() fmodel['mfs'] = self.mfs fmodel['rules'] = self.rules fmodel['result'] = self.objectives[1] print('Error = ', self.objectives[1]) return fmodel
def __init__(self): #inputs self.catch = ctrl.Antecedent(np.arange(58, 70, 0.1), 'Catch') self.catch['Novice'] = fuzz.trapmf(self.catch.universe, [0,58,60,61.5]) self.catch['Intermediate'] = fuzz.gaussmf(self.catch.universe, 63.1, 0.7) self.catch['National'] = fuzz.gaussmf(self.catch.universe, 65.7, 0.7) self.catch['International'] = fuzz.trapmf(self.catch.universe, [67.6, 68.2, 70, 70]) self.finish = ctrl.Antecedent(np.arange(38, 46, 0.1), 'Finish') self.finish['Novice'] = fuzz.trapmf(self.finish.universe, [0,38,38,38.9]) self.finish['Intermediate'] = fuzz.gaussmf(self.finish.universe, 40.8, 0.8) self.finish['National'] = fuzz.gaussmf(self.finish.universe, 43.1, 0.8) self.finish['International'] = fuzz.trapmf(self.finish.universe, [45.1, 45.8, 46, 46]) self.slip = ctrl.Antecedent(np.arange(2, 8, 0.1), 'Slip') self.slip['Novice'] = fuzz.trapmf(self.slip.universe, [6.9, 7.4, 8,8]) self.slip['Intermediate'] = fuzz.gaussmf(self.slip.universe, 5.6, 0.4) self.slip['National'] = fuzz.gaussmf(self.slip.universe, 4.1, 0.4) self.slip['International'] = fuzz.trapmf(self.slip.universe, [2, 2, 2.2, 2.9]) self.wash = ctrl.Antecedent(np.arange(9, 20, 0.1), 'Wash') self.wash['Novice'] = fuzz.trapmf(self.wash.universe, [18.9, 19.4, 20, 20]) self.wash['Intermediate'] = fuzz.gaussmf(self.wash.universe, 16.8, 1) self.wash['National'] = fuzz.gaussmf(self.wash.universe, 14.3, 1) self.wash['International'] = fuzz.trapmf(self.wash.universe, [9,9, 10.9,12.5]) self.length = ctrl.Antecedent(np.arange(95, 115, 0.1), 'Length') self.length['Novice'] = fuzz.trapmf(self.length.universe, [95,95,100.2,102.3]) self.length['Intermediate'] = fuzz.gaussmf(self.length.universe, 104.7, 1.2) self.length['National'] = fuzz.gaussmf(self.length.universe, 108, 1.2) self.length['International'] = fuzz.trapmf(self.length.universe, [108.0, 111.4, 115,115]) #output self.quality = ctrl.Consequent(np.arange(0, 101, 0.1), 'Quality') #setting membership functions self.quality['Novice'] = fuzz.gaussmf(self.quality.universe, 0, 10) self.quality['Intermediate'] = fuzz.gaussmf(self.quality.universe, 40, 8) self.quality['National'] = fuzz.gaussmf(self.quality.universe, 60, 8) self.quality['International'] = fuzz.gaussmf(self.quality.universe, 100, 10) #catch rule1 = ctrl.Rule(self.catch['Novice'], self.quality['Novice']) rule2 = ctrl.Rule(self.catch['Intermediate'], self.quality['Intermediate']) rule3 = ctrl.Rule(self.catch['National'], self.quality['National']) rule4 = ctrl.Rule(self.catch['International'], self.quality['International']) #finish rule5 = ctrl.Rule(self.finish['Novice'], self.quality['Novice']) rule6 = ctrl.Rule(self.finish['Intermediate'], self.quality['Intermediate']) rule7 = ctrl.Rule(self.finish['National'], self.quality['National']) rule8 = ctrl.Rule(self.finish['International'], self.quality['International']) #slip rule9 = ctrl.Rule(self.slip['Novice'], self.quality['Novice']) rule10 = ctrl.Rule(self.slip['Intermediate'], self.quality['Intermediate']) rule11 = ctrl.Rule(self.slip['National'], self.quality['National']) rule12 = ctrl.Rule(self.slip['International'], self.quality['International']) #wash rule13 = ctrl.Rule(self.wash['Novice'], self.quality['Novice']) rule14 = ctrl.Rule(self.wash['Intermediate'], self.quality['Intermediate']) rule15 = ctrl.Rule(self.wash['National'], self.quality['National']) rule16 = ctrl.Rule(self.wash['International'], self.quality['International']) #length rule17 = ctrl.Rule(self.length['Novice'], self.quality['Novice']) rule18 = ctrl.Rule(self.length['Intermediate'], self.quality['Intermediate']) rule19 = ctrl.Rule(self.length['National'], self.quality['National']) rule20 = ctrl.Rule(self.length['International'], self.quality['International']) rowingFIS_ctrl = ctrl.ControlSystem([ rule1, rule2, rule3, rule4, #catch rule5, rule6, rule7, rule8,#finish rule9, rule10, rule11, rule12,#slip rule13, rule14, rule15, rule16,#wash rule17, rule18, rule19, rule20#length ]) self.rowingFis = ctrl.ControlSystemSimulation(rowingFIS_ctrl)
if temperature is hot then ice cream parlor is crowded. if temperature is moderate then ice cream parlor is busy. if temperature is cool then ice cream parlor is quiet. """ import numpy as np import skfuzzy as fuzz import matplotlib.pyplot as plt #Univerese functions temp = np.arange(30, 101, 1) customers = np.arange(0,36, 1) #Membership function for heat t_hot = fuzz.trimf(temp, [65, 100, 100]) t_mod = fuzz.trimf(temp, [30, 65, 100]) t_cool = fuzz.trapmf(temp, [20, 20, 30, 65]) #Membership function for customers c_crowded = fuzz.trimf(customers, [24, 35, 35]) c_busy = fuzz.trimf(customers, [0, 24, 35]) c_quiet = fuzz.trimf(customers, [0, 0, 24]) """Visualise system""" # Visualize membership functions for temperature '''fig, ax = plt.subplots() ax.plot(temp, t_hot, 'r', temp, t_mod, 'm', temp, t_cool, 'b') ax.set_ylabel('Fuzzy membership')
def calculate_obj2(value_ini_21, value_ini_22, value_ini_23): #OBJETIVO 2: Crear experiencias gratamente memorables para posicionar la marca EMTEL en el corazón de los clientes # Generate universe variables # El rango de las iniciativas estrategicas es [0,110] # El rango del objetivo de salida es [0,110] # Inic1 = Crear cultura basada en la experiencia # Inic2 = Alcanzar los tiempos promedio de instalacion y reparación requeridos # Inic3 = Garantizar los niveles de calidad establecidos en la prestación de los servicios TIC # New Antecedent/Consequent objects hold universe variables and membership # functions Inic1 = ctrl.Antecedent(np.arange(0, 110, 1), 'Inic1') Inic2 = ctrl.Antecedent(np.arange(0, 110, 1), 'Inic2') Inic3 = ctrl.Antecedent(np.arange(0, 110, 1), 'Inic3') Obj2 = ctrl.Consequent(np.arange(0, 110, 1), 'Objetivo 2') # Generate fuzzy membership functions Inic1['Dmayor'] = fuzz.trapmf(Inic1.universe, [-1, 0, 20, 29]) Inic1['Dmenor'] = fuzz.trimf(Inic1.universe, [30, 40, 55]) Inic1['Fmenor'] = fuzz.trimf(Inic1.universe, [44, 60, 78]) Inic1['Fmayor'] = fuzz.trapmf(Inic1.universe, [76, 80, 110, 120]) Inic2['Dmayor'] = fuzz.trapmf(Inic2.universe, [-1, 0, 20, 29]) Inic2['Dmenor'] = fuzz.trimf(Inic2.universe, [32, 40, 58]) Inic2['Fmenor'] = fuzz.trimf(Inic2.universe, [36, 60, 69]) Inic2['Fmayor'] = fuzz.trapmf(Inic2.universe, [75, 80, 110, 120]) Inic3['Dmayor'] = fuzz.trapmf(Inic3.universe, [-1, 0, 20, 22]) Inic3['Dmenor'] = fuzz.trimf(Inic3.universe, [31, 40, 55]) Inic3['Fmenor'] = fuzz.trimf(Inic3.universe, [44, 60, 77]) Inic3['Fmayor'] = fuzz.trapmf(Inic3.universe, [72, 80, 110, 120]) Obj2['Dmayor'] = fuzz.trapmf(Obj2.universe, [-1, 0, 20, 35]) Obj2['Dmenor'] = fuzz.trimf(Obj2.universe, [30, 40, 55]) Obj2['Fmenor'] = fuzz.trimf(Obj2.universe, [50, 60, 76]) Obj2['Fmayor'] = fuzz.trapmf(Obj2.universe, [60, 80, 110, 120]) #generate rules membreship rule1 = ctrl.Rule(Inic1['Dmenor'] | Inic2['Fmenor'], Obj2['Fmenor']) rule2 = ctrl.Rule(Inic1['Fmayor'], Obj2['Fmenor']) rule3 = ctrl.Rule(Inic1['Fmayor'] & Inic2['Fmayor'], Obj2['Fmayor']) rule4 = ctrl.Rule(Inic1['Fmenor'] & Inic3['Fmenor'], Obj2['Fmenor']) rule5 = ctrl.Rule(Inic3['Fmayor'] | Inic2['Fmayor'] | Inic1['Fmayor'], Obj2['Fmenor']) #create system control and simulation solving_ctrl = ctrl.ControlSystem([rule1, rule2, rule3, rule4, rule5]) solving = ctrl.ControlSystemSimulation(solving_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) solving.input['Inic1'] = value_ini_21 solving.input['Inic2'] = value_ini_22 solving.input['Inic3'] = value_ini_23 # Crunch the numbers solving.compute() #value objetivo 2 Obj2_result = solving.output['Objetivo 2'] #update data n = 1 data = [['Objetivo', 'Valor'], ['Objetivo 1', 0], ['Objetivo 2', 0], ['Objetivo 3', 0], ['Objetivo 4', 0], ['Objetivo 5', 0], ['Objetivo 6', 0], ['Objetivo 7', 0]] with open('static/data/datamain.csv', newline='') as csvfile: reader = csv.DictReader(csvfile) for row in reader: data[n] = ['Objetivo', row['Valor']] n = n + 1 #update table data[2][1] = Obj2_result with open('static/data/datamain.csv', 'w') as csvFile: writer = csv.writer(csvFile) writer.writerows(data) csvFile.close()
def controle_fuzzy(): # Descrição do conjunto universo para os antecedentes e consequentes posicao_lateral = ctrl.Antecedent(np.arange(-90, 90, 0.1), 'Posicao Lateral') posicao_derivadaerro = ctrl.Antecedent(np.arange(-3000, 3000, 0.1), 'Derivada Erro') posicao_frontal = ctrl.Antecedent(np.arange(30, 1120, 0.1), 'Posicao Frontal') angulo_volante = ctrl.Consequent(np.arange(-35, 35, 0.1), 'Angulo Volante') velocidade = ctrl.Consequent(np.arange(-1, 8, 0.1), 'Velocidade') # Funções de pertinência para a derivada do erro posicao_derivadaerro['Muito Direita'] = fuzz.trapmf( posicao_derivadaerro.universe, [-3000, -2900, -800, -90]) posicao_derivadaerro['Direita'] = fuzz.trapmf( posicao_derivadaerro.universe, [-800, -600, -150, 0]) posicao_derivadaerro['Meio'] = fuzz.trimf(posicao_derivadaerro.universe, [-150, 0, 150]) posicao_derivadaerro['Esquerda'] = fuzz.trapmf( posicao_derivadaerro.universe, [0, 150, 500, 600]) posicao_derivadaerro['Muito Esquerda'] = fuzz.trapmf( posicao_derivadaerro.universe, [600, 800, 2900, 3000]) # Funções de pertinência para os sensores laterais posicao_lateral['Muito Direita'] = fuzz.trapmf(posicao_lateral.universe, [-100, -90, -70, -35]) posicao_lateral['Direita'] = fuzz.trapmf(posicao_lateral.universe, [-40, -20, -10, 0]) posicao_lateral['Meio'] = fuzz.trimf(posicao_lateral.universe, [-15, 0, 15]) posicao_lateral['Esquerda'] = fuzz.trapmf(posicao_lateral.universe, [0, 10, 25, 40]) posicao_lateral['Muito Esquerda'] = fuzz.trapmf(posicao_lateral.universe, [35, 70, 90, 100]) # Funções de pertinência para o sensor frontal posicao_frontal['Perto'] = fuzz.trapmf(posicao_frontal.universe, [-1, 0, 100, 150]) posicao_frontal['Longe'] = fuzz.trapmf(posicao_frontal.universe, [120, 450, 900, 1130]) # Funções de pertinência para os sensores laterais angulo_volante['Muito Direita'] = fuzz.trapmf(angulo_volante.universe, [-33, -30, -15, -10]) angulo_volante['Direita'] = fuzz.trapmf(angulo_volante.universe, [-12, -8, -2, 0]) angulo_volante['Meio'] = fuzz.trimf(angulo_volante.universe, [-2, 0, 2]) angulo_volante['Esquerda'] = fuzz.trapmf(angulo_volante.universe, [0, 2, 8, 12]) angulo_volante['Muito Esquerda'] = fuzz.trapmf(angulo_volante.universe, [10, 15, 30, 35]) # Funções de pertinência para o sensor frontal velocidade['Devagar'] = fuzz.trimf(velocidade.universe, [0.5, 2.5, 4]) velocidade['Rapido'] = fuzz.trimf(velocidade.universe, [3, 7, 10]) #Regras rule1 = ctrl.Rule( posicao_lateral['Meio'] & posicao_frontal['Longe'] & posicao_derivadaerro['Meio'], angulo_volante['Meio']) rule1_2 = ctrl.Rule( posicao_lateral['Meio'] & posicao_frontal['Longe'] & posicao_derivadaerro['Meio'], velocidade['Rapido']) rule2 = ctrl.Rule( posicao_lateral['Esquerda'] & posicao_frontal['Perto'] & posicao_derivadaerro['Muito Esquerda'], angulo_volante['Muito Direita']) rule2_2 = ctrl.Rule(posicao_lateral['Esquerda'] & posicao_frontal['Perto'] & posicao_derivadaerro['Muito Esquerda'], velocidade['Devagar']) #Devagar rule3 = ctrl.Rule( posicao_lateral['Direita'] & posicao_frontal['Perto'] & posicao_derivadaerro['Muito Direita'], angulo_volante['Muito Esquerda']) rule3_2 = ctrl.Rule(posicao_lateral['Direita'] & posicao_frontal['Perto'] & posicao_derivadaerro['Muito Direita'], velocidade['Devagar']) #Devagar rule4 = ctrl.Rule( posicao_lateral['Esquerda'] & posicao_frontal['Longe'] & posicao_derivadaerro['Esquerda'], angulo_volante['Meio']) rule4_2 = ctrl.Rule( posicao_lateral['Esquerda'] & posicao_frontal['Longe'] & posicao_derivadaerro['Esquerda'], velocidade['Rapido']) rule5 = ctrl.Rule( posicao_lateral['Direita'] & posicao_frontal['Longe'] & posicao_derivadaerro['Direita'], angulo_volante['Meio']) rule5_2 = ctrl.Rule( posicao_lateral['Direita'] & posicao_frontal['Longe'] & posicao_derivadaerro['Direita'], velocidade['Rapido']) rule6 = ctrl.Rule( posicao_lateral['Meio'] & posicao_frontal['Perto'] & posicao_derivadaerro['Meio'], angulo_volante['Meio']) rule6_2 = ctrl.Rule(posicao_lateral['Meio'] & posicao_frontal['Perto'] & posicao_derivadaerro['Meio'], velocidade['Rapido']) #Devagar rule7 = ctrl.Rule( posicao_lateral['Muito Esquerda'] & posicao_frontal['Perto'] & posicao_derivadaerro['Muito Esquerda'], angulo_volante['Muito Direita']) rule7_2 = ctrl.Rule( posicao_lateral['Muito Esquerda'] & posicao_frontal['Perto'] & posicao_derivadaerro['Muito Esquerda'], velocidade['Devagar']) rule8 = ctrl.Rule( posicao_lateral['Muito Direita'] & posicao_frontal['Perto'] & posicao_derivadaerro['Muito Direita'], angulo_volante['Muito Esquerda']) rule8_2 = ctrl.Rule( posicao_lateral['Muito Direita'] & posicao_frontal['Perto'] & posicao_derivadaerro['Muito Direita'], velocidade['Devagar']) rule9 = ctrl.Rule( posicao_lateral['Muito Esquerda'] & posicao_frontal['Longe'] & posicao_derivadaerro['Esquerda'], angulo_volante['Direita']) rule9_2 = ctrl.Rule( posicao_lateral['Muito Esquerda'] & posicao_frontal['Longe'] & posicao_derivadaerro['Esquerda'], velocidade['Rapido']) rule10 = ctrl.Rule( posicao_lateral['Muito Direita'] & posicao_frontal['Longe'] & posicao_derivadaerro['Direita'], angulo_volante['Esquerda']) rule10_2 = ctrl.Rule( posicao_lateral['Muito Direita'] & posicao_frontal['Longe'] & posicao_derivadaerro['Direita'], velocidade['Rapido']) rule11 = ctrl.Rule( posicao_lateral['Direita'] & posicao_frontal['Longe'] & posicao_derivadaerro['Meio'], angulo_volante['Esquerda']) rule11_2 = ctrl.Rule( posicao_lateral['Direita'] & posicao_frontal['Longe'] & posicao_derivadaerro['Meio'], velocidade['Rapido']) rule12 = ctrl.Rule( posicao_lateral['Esquerda'] & posicao_frontal['Longe'] & posicao_derivadaerro['Meio'], angulo_volante['Direita']) rule12_2 = ctrl.Rule( posicao_lateral['Esquerda'] & posicao_frontal['Longe'] & posicao_derivadaerro['Meio'], velocidade['Rapido']) rule13 = ctrl.Rule( posicao_lateral['Muito Esquerda'] & posicao_frontal['Perto'] & posicao_derivadaerro['Meio'], angulo_volante['Muito Direita']) rule13_2 = ctrl.Rule( posicao_lateral['Muito Esquerda'] & posicao_frontal['Perto'] & posicao_derivadaerro['Meio'], velocidade['Devagar']) rule14 = ctrl.Rule( posicao_lateral['Muito Direita'] & posicao_frontal['Perto'] & posicao_derivadaerro['Meio'], angulo_volante['Muito Esquerda']) rule14_2 = ctrl.Rule( posicao_lateral['Muito Direita'] & posicao_frontal['Perto'] & posicao_derivadaerro['Meio'], velocidade['Devagar']) rule15 = ctrl.Rule( posicao_lateral['Esquerda'] & posicao_frontal['Perto'] & posicao_derivadaerro['Esquerda'], angulo_volante['Muito Direita']) rule15_2 = ctrl.Rule(posicao_lateral['Esquerda'] & posicao_frontal['Perto'] & posicao_derivadaerro['Esquerda'], velocidade['Devagar']) #Devagar rule16 = ctrl.Rule( posicao_lateral['Direita'] & posicao_frontal['Perto'] & posicao_derivadaerro['Direita'], angulo_volante['Muito Esquerda']) rule16_2 = ctrl.Rule(posicao_lateral['Direita'] & posicao_frontal['Perto'] & posicao_derivadaerro['Direita'], velocidade['Devagar']) #Devagar rule17 = ctrl.Rule( posicao_lateral['Direita'] & posicao_frontal['Perto'] & posicao_derivadaerro['Meio'], angulo_volante['Muito Esquerda']) rule17_2 = ctrl.Rule( posicao_lateral['Direita'] & posicao_frontal['Perto'] & posicao_derivadaerro['Meio'], velocidade['Devagar']) rule18 = ctrl.Rule( posicao_lateral['Esquerda'] & posicao_frontal['Perto'] & posicao_derivadaerro['Meio'], angulo_volante['Muito Direita']) rule18_2 = ctrl.Rule( posicao_lateral['Esquerda'] & posicao_frontal['Perto'] & posicao_derivadaerro['Meio'], velocidade['Devagar']) rule19 = ctrl.Rule( posicao_lateral['Direita'] & posicao_frontal['Longe'] & posicao_derivadaerro['Esquerda'], angulo_volante['Esquerda']) rule19_2 = ctrl.Rule( posicao_lateral['Direita'] & posicao_frontal['Longe'] & posicao_derivadaerro['Esquerda'], velocidade['Rapido']) rule20 = ctrl.Rule(posicao_lateral['Direita'] & posicao_frontal['Perto'] & posicao_derivadaerro['Esquerda'], angulo_volante['Muito Esquerda']) # rule20_2 = ctrl.Rule( posicao_lateral['Direita'] & posicao_frontal['Perto'] & posicao_derivadaerro['Esquerda'], velocidade['Devagar']) rule21 = ctrl.Rule( posicao_lateral['Esquerda'] & posicao_frontal['Longe'] & posicao_derivadaerro['Direita'], angulo_volante['Direita']) rule21_2 = ctrl.Rule( posicao_lateral['Esquerda'] & posicao_frontal['Longe'] & posicao_derivadaerro['Direita'], velocidade['Rapido']) rule22 = ctrl.Rule( posicao_lateral['Esquerda'] & posicao_frontal['Perto'] & posicao_derivadaerro['Direita'], angulo_volante['Muito Esquerda']) rule22_2 = ctrl.Rule( posicao_lateral['Esquerda'] & posicao_frontal['Perto'] & posicao_derivadaerro['Direita'], velocidade['Devagar']) rule23 = ctrl.Rule( posicao_lateral['Muito Esquerda'] & posicao_frontal['Longe'] & posicao_derivadaerro['Meio'], angulo_volante['Direita']) rule23_2 = ctrl.Rule( posicao_lateral['Muito Esquerda'] & posicao_frontal['Longe'] & posicao_derivadaerro['Meio'], velocidade['Rapido']) rule24 = ctrl.Rule( posicao_lateral['Muito Direita'] & posicao_frontal['Longe'] & posicao_derivadaerro['Meio'], angulo_volante['Esquerda']) rule24_2 = ctrl.Rule( posicao_lateral['Muito Direita'] & posicao_frontal['Longe'] & posicao_derivadaerro['Meio'], velocidade['Rapido']) car_ctrl = ctrl.ControlSystem([ rule1, rule1_2, rule2, rule2_2, rule3, rule3_2, rule4, rule4_2, rule5, rule5_2, rule6, rule6_2, rule7, rule7_2, rule8, rule8_2, rule9, rule9_2, rule10, rule10_2, rule11, rule11_2, rule12, rule12_2, rule13, rule13_2, rule14, rule14_2, rule15, rule15_2, rule16, rule16_2, rule17, rule17_2, rule18, rule18_2, rule19, rule19_2, rule20, rule20_2, rule21, rule21_2, rule22, rule22_2, rule23, rule23_2, rule24, rule24_2 ]) carro = ctrl.ControlSystemSimulation(car_ctrl) return carro
def __init__(self, intensidade_interacoes_AC, intensidade_interacoes_BC, similaridade_entre_vertices, idade_interacoes_AC, idade_interacoes_BC): print intensidade_interacoes_AC, intensidade_interacoes_BC, similaridade_entre_vertices, idade_interacoes_AC,idade_interacoes_BC self.intensidade_interacoes_AC = intensidade_interacoes_AC self.intensidade_interacoes_BC = intensidade_interacoes_BC self.similaridade_entre_vertices = similaridade_entre_vertices self.idade_interacoes_AC = idade_interacoes_AC self.idade_interacoes_BC = idade_interacoes_BC # Generate universe variables self.x_intensidade_interacoes_AC = np.arange(0, 10, 1) self.x_intensidade_interacoes_BC = np.arange(0, 10, 1) self.x_similaridade_entre_vertices = np.arange(0, 101, 1) self.x_idade_interacoes_AC = np.arange(0, 10, 1) self.x_idade_interacoes_BC = np.arange(0, 10, 1) self.x_potencial_ligacao = np.arange(0, 100, 1) # Generate fuzzy membership functions self.intensidade_interacoes_AC_baixa = fuzz.trimf(self.x_intensidade_interacoes_AC, [0, 0, 6]) self.intensidade_interacoes_AC_alta = fuzz.trapmf(self.x_intensidade_interacoes_AC, [2, 6, 10, 10]) self.intensidade_interacoes_BC_baixa = fuzz.trimf(self.x_intensidade_interacoes_BC, [0, 0, 6]) self.intensidade_interacoes_BC_alta = fuzz.trapmf(self.x_intensidade_interacoes_BC, [2, 6, 10, 10]) self.similaridade_entre_vertices_baixa = fuzz.trimf(self.x_similaridade_entre_vertices, [0, 0, 60]) self.similaridade_entre_vertices_alta = fuzz.trimf(self.x_similaridade_entre_vertices, [40, 100, 100]) self.idade_interacoes_AC_baixa = fuzz.trimf(self.x_idade_interacoes_AC, [0, 0, 6]) self.idade_interacoes_AC_alta = fuzz.trimf(self.x_idade_interacoes_AC, [4, 10, 10]) self.idade_interacoes_BC_baixa = fuzz.trimf(self.x_idade_interacoes_BC, [0, 0, 6]) self.idade_interacoes_BC_alta = fuzz.trimf(self.x_idade_interacoes_BC, [4, 10, 10]) self.potencial_ligacao_baixo = fuzz.trimf(self.x_potencial_ligacao, [0, 0, 60]) self.potencial_ligacao_medio = fuzz.trimf(self.x_potencial_ligacao, [10, 50, 90]) self.potencial_ligacao_alto = fuzz.trimf(self.x_potencial_ligacao, [40, 100, 100]) self.grau_intensidade_interacoes_AC_baixa = fuzz.interp_membership(self.x_intensidade_interacoes_AC, self.intensidade_interacoes_AC_baixa, intensidade_interacoes_AC) self.grau_intensidade_interacoes_AC_alta = fuzz.interp_membership(self.x_intensidade_interacoes_AC, self.intensidade_interacoes_AC_alta, intensidade_interacoes_AC) self.grau_intensidade_interacoes_BC_baixa = fuzz.interp_membership(self.x_intensidade_interacoes_BC, self.intensidade_interacoes_BC_baixa, intensidade_interacoes_BC) self.grau_intensidade_interacoes_BC_alta = fuzz.interp_membership(self.x_intensidade_interacoes_BC, self.intensidade_interacoes_BC_alta, intensidade_interacoes_BC) self.grau_similaridade_entre_vertices_baixa = fuzz.interp_membership(self.x_similaridade_entre_vertices, self.similaridade_entre_vertices_baixa, similaridade_entre_vertices) self.grau_similaridade_entre_vertices_alta = fuzz.interp_membership(self.x_similaridade_entre_vertices, self.similaridade_entre_vertices_alta, similaridade_entre_vertices) self.grau_idade_interacoes_AC_baixa = fuzz.interp_membership(self.x_idade_interacoes_AC, self.idade_interacoes_AC_baixa, self.idade_interacoes_AC) self.grau_idade_interacoes_AC_alta = fuzz.interp_membership(self.x_idade_interacoes_AC, self.idade_interacoes_AC_alta, self.idade_interacoes_AC) self.grau_idade_interacoes_BC_baixa = fuzz.interp_membership(self.x_idade_interacoes_BC, self.idade_interacoes_BC_baixa, self.idade_interacoes_BC) self.grau_idade_interacoes_BC_alta = fuzz.interp_membership(self.x_idade_interacoes_BC, self.idade_interacoes_BC_alta, self.idade_interacoes_BC) active_rule1 = np.fmin(self.grau_intensidade_interacoes_AC_alta, np.fmin(self.grau_intensidade_interacoes_BC_alta, np.fmin(self.grau_similaridade_entre_vertices_alta, np.fmin(self.grau_idade_interacoes_AC_baixa, self.grau_idade_interacoes_BC_baixa)))) potencial_ligacao_rule1 = np.fmin(active_rule1, self.potencial_ligacao_alto) print('active_rule1 ', active_rule1) active_rule2 = np.fmin(self.grau_intensidade_interacoes_AC_baixa, np.fmin(self.grau_intensidade_interacoes_BC_baixa, np.fmin(self.grau_similaridade_entre_vertices_baixa, np.fmin(self.grau_idade_interacoes_AC_alta, self.grau_idade_interacoes_BC_alta)))) potencial_ligacao_rule2 = np.fmin(active_rule2, self.potencial_ligacao_baixo) print('active_rule2 ', active_rule2) #print('potencial_ligacao_rule2 ', potencial_ligacao_rule2) active_rule3 = np.fmin(self.grau_intensidade_interacoes_AC_alta, np.fmin(self.grau_intensidade_interacoes_BC_alta, np.fmin(self.grau_similaridade_entre_vertices_baixa, np.fmin(self.grau_idade_interacoes_AC_baixa, self.grau_idade_interacoes_BC_baixa)))) potencial_ligacao_rule3 = np.fmin(active_rule3, self.potencial_ligacao_medio) print('active_rule3 ', active_rule3) #print('potencial_ligacao_rule3 ', potencial_ligacao_rule3) active_rule4 = np.fmin(self.grau_intensidade_interacoes_AC_baixa, np.fmin(self.grau_intensidade_interacoes_BC_baixa, np.fmin(self.grau_similaridade_entre_vertices_alta, np.fmin(self.grau_idade_interacoes_AC_baixa, self.grau_idade_interacoes_BC_baixa)))) potencial_ligacao_rule4 = np.fmin(active_rule4, self.potencial_ligacao_medio) print('active_rule4 ', active_rule4) #print('potencial_ligacao_rule4 ', potencial_ligacao_rule4) # Aggregate all three output membership functions together aggregated = np.fmax(potencial_ligacao_rule1, np.fmax(potencial_ligacao_rule2, np.fmax(potencial_ligacao_rule3, potencial_ligacao_rule4))) # Calculate defuzzified result self.potencial_ligacao = fuzz.defuzz(self.x_potencial_ligacao, aggregated, 'centroid') self.grau_potencial_ligacao = fuzz.interp_membership(self.x_potencial_ligacao, aggregated, self.potencial_ligacao)
import skfuzzy as fuzz from skfuzzy import control as ctrl import numpy as np import matplotlib.pyplot as plt import seaborn as sns sns.set() from mpl_toolkits.mplot3d import Axes3D driving = ctrl.Antecedent(np.arange(0, 101, 1), 'driving') journey_time = ctrl.Antecedent(np.arange(0, 21, 1), 'journey_time') tip = ctrl.Consequent(np.arange(0, 210, 1), 'tip') driving['bad'] = fuzz.trapmf(driving.universe, [0, 0, 30, 50]) driving['average'] = fuzz.trapmf(driving.universe, [30, 50, 50, 70]) driving['good'] = fuzz.trapmf(driving.universe, [60, 80, 100, 100]) journey_time['short'] = fuzz.trapmf(journey_time.universe, [0, 0, 0, 10]) journey_time['medium'] = fuzz.trapmf(journey_time.universe, [5, 10, 10, 15]) journey_time['long'] = fuzz.trapmf(journey_time.universe, [10, 20, 20, 20]) tip['small'] = fuzz.trapmf(tip.universe, [0, 50, 50, 100]) tip['moderate'] = fuzz.trapmf(tip.universe, [50, 100, 100, 150]) tip['big'] = fuzz.trapmf(tip.universe, [100, 150, 150, 200]) # driving.view() # journey_time.view() # tip.view() # plt.show() rule1 = ctrl.Rule(driving['good'] & journey_time['short'], tip['big'])
def calculate_obj1(value_ini_11, value_ini_12): #OBJETIVO 1: GARANTIZAR LA SOSTENEBILIDAD ECONOMICA DE LA ORGANIZACION # Generate universe variables # El rango de las iniciativas estrategicas es [0,110] # El rango del objetivo de salida es [0,110] # Inic1 = Disminuir los pasivos a corto plazo # Inic2 = Incrementar los ingresos # New Antecedent/Consequent objects hold universe variables and membership # functions Inic_1_1 = ctrl.Antecedent(np.arange(0, 110, 1), 'Disminuir los pasivos...') Inic_1_2 = ctrl.Antecedent(np.arange(0, 110, 1), 'Incrementar los ingresos') Obj1 = ctrl.Consequent(np.arange(0, 110, 1), 'Objetivo 1') # Generate fuzzy membership functions Inic_1_1['Dmayor'] = fuzz.trapmf(Inic_1_1.universe, [-1, 0, 20, 29]) Inic_1_1['Dmenor'] = fuzz.trimf(Inic_1_1.universe, [12, 40, 46]) Inic_1_1['Fmenor'] = fuzz.trimf(Inic_1_1.universe, [36, 60, 72]) Inic_1_1['Fmayor'] = fuzz.trapmf(Inic_1_1.universe, [76, 80, 110, 120]) Inic_1_2['Dmayor'] = fuzz.trapmf(Inic_1_2.universe, [-1, 0, 20, 35]) Inic_1_2['Dmenor'] = fuzz.trimf(Inic_1_2.universe, [37, 40, 56]) Inic_1_2['Fmenor'] = fuzz.trimf(Inic_1_2.universe, [56, 60, 75]) Inic_1_2['Fmayor'] = fuzz.trapmf(Inic_1_2.universe, [72, 80, 110, 120]) Obj1['Dmayor'] = fuzz.trapmf(Obj1.universe, [-1, 0, 20, 35]) Obj1['Dmenor'] = fuzz.trimf(Obj1.universe, [30, 40, 55]) Obj1['Fmenor'] = fuzz.trimf(Obj1.universe, [50, 60, 76]) Obj1['Fmayor'] = fuzz.trapmf(Obj1.universe, [60, 80, 110, 120]) # generate rules rule_1_1 = ctrl.Rule(Inic_1_1['Dmenor'] | Inic_1_2['Fmenor'], Obj1['Fmenor']) rule_1_2 = ctrl.Rule(Inic_1_1['Fmayor'], Obj1['Fmenor']) rule_1_3 = ctrl.Rule(Inic_1_1['Fmayor'] & Inic_1_2['Fmayor'], Obj1['Fmayor']) #create system control and simulation solving_ctrl_obj1 = ctrl.ControlSystem([rule_1_1, rule_1_2, rule_1_3]) solving_obj1 = ctrl.ControlSystemSimulation(solving_ctrl_obj1) # 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) solving_obj1.input['Disminuir los pasivos...'] = value_ini_11 solving_obj1.input['Incrementar los ingresos'] = value_ini_12 # Crunch the numbers solving_obj1.compute() #value objetivo 1 Obj1_result = solving_obj1.output['Objetivo 1'] #update data n = 1 data = [['Objetivo', 'Valor'], ['Objetivo 1', 0], ['Objetivo 2', 0], ['Objetivo 3', 0], ['Objetivo 4', 0], ['Objetivo 5', 0], ['Objetivo 6', 0], ['Objetivo 7', 0]] with open('static/data/datamain.csv', newline='') as csvfile: reader = csv.DictReader(csvfile) for row in reader: data[n] = ['Objetivo', row['Valor']] n = n + 1 data[1][1] = Obj1_result with open('static/data/datamain.csv', 'w') as csvFile: writer = csv.writer(csvFile) writer.writerows(data) csvFile.close()
import matplotlib.pyplot as plt kwargs = {'lw': 20, 'solid_capstyle': 'round'} if __name__ == '__main__': # Generate membership functions corresponding to S, F, I, and U in logo x_sf = np.arange(0, 3.1, 0.1) - 0.1 x_f2 = np.arange(0, 2.7, 0.1) - 0.1 x_i = np.arange(3.6, 4.05, 0.1) x_u1 = np.arange(3.0, 3.45, 0.1) x_u2 = np.arange(3.0, 4.05, 0.1) x_u3 = np.arange(4.0, 4.45, 0.1) s_mf = fuzz.trapmf(x_sf, [1, 2, 3, 3]) * (2. / 3) + 0.4 f_mf1 = fuzz.trapmf(x_sf, [1, 2, 3, 3]) * (2. / 3) f_mf2 = fuzz.trapmf(x_f2, [1, 1.6, 2.6, 2.6]) * 0.4 i_mf = (x_i - 3.6) * (2. / 3) + 0.4 u1_mf = (x_u1 - 3) * (2. / 3) u2_mf = np.zeros_like(x_u2) u3_mf = (x_u3 - 4) * (2. / 3) bot = 0.4 * 2 / 3 # Plot various membership functions fig, ax = plt.subplots(figsize=(8, 6)) s = ax.plot(x_sf, s_mf, 'k', **kwargs) f1 = ax.plot(x_sf + 0.4, f_mf1, 'k', **kwargs) f2 = ax.plot(x_f2 + 0.4, f_mf2, 'k', **kwargs)
def calculate_obj3(value_ini_31): #OBJETIVO 3: INCURSIONAR EN NUEVAS OPORTUNIDADES DE NEGOCIO # Generate universe variables # El rango de las iniciativas estrategicas es [0,110] # El rango del objetivo de salida es [0,110] # Inic1 = Generar nuevas oportunidades de negocio # New Antecedent/Consequent objects hold universe variables and membership # functions Inic1 = ctrl.Antecedent(np.arange(0, 110, 1), 'Inic1') Obj3 = ctrl.Consequent(np.arange(0, 110, 1), 'Objetivo 3') # Generate fuzzy membership functions Inic1['Dmayor'] = fuzz.trapmf(Inic1.universe, [-1, 0, 20, 26]) Inic1['Dmenor'] = fuzz.trimf(Inic1.universe, [21, 40, 57]) Inic1['Fmenor'] = fuzz.trimf(Inic1.universe, [55, 60, 79]) Inic1['Fmayor'] = fuzz.trapmf(Inic1.universe, [72, 80, 110, 120]) Obj3['Dmayor'] = fuzz.trapmf(Obj3.universe, [-1, 0, 20, 35]) Obj3['Dmenor'] = fuzz.trimf(Obj3.universe, [30, 40, 55]) Obj3['Fmenor'] = fuzz.trimf(Obj3.universe, [50, 60, 76]) Obj3['Fmayor'] = fuzz.trapmf(Obj3.universe, [60, 80, 110, 120]) #generate rules membreship rule1 = ctrl.Rule(Inic1['Dmayor'], Obj3['Dmayor']) rule2 = ctrl.Rule(Inic1['Dmenor'], Obj3['Dmenor']) rule3 = ctrl.Rule(Inic1['Fmenor'], Obj3['Fmenor']) rule4 = ctrl.Rule(Inic1['Fmayor'], Obj3['Fmayor']) #create system control and simulation solving_ctrl = ctrl.ControlSystem([rule1, rule2, rule3, rule4]) solving = ctrl.ControlSystemSimulation(solving_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) solving.input['Inic1'] = value_ini_31 # Crunch the numbers solving.compute() #value objetivo 3 Obj3_result = solving.output['Objetivo 3'] #update data n = 1 data = [['Objetivo', 'Valor'], ['Objetivo 1', 0], ['Objetivo 2', 0], ['Objetivo 3', 0], ['Objetivo 4', 0], ['Objetivo 5', 0], ['Objetivo 6', 0], ['Objetivo 7', 0]] with open('static/data/datamain.csv', newline='') as csvfile: reader = csv.DictReader(csvfile) for row in reader: data[n] = ['Objetivo', row['Valor']] n = n + 1 #update table data[3][1] = Obj3_result with open('static/data/datamain.csv', 'w') as csvFile: writer = csv.writer(csvFile) writer.writerows(data) csvFile.close()
import numpy as np import skfuzzy as fuzz from skfuzzy import control as ctrl # Cria as variáveis do problema air_temp = ctrl.Antecedent(np.arange(0, 51, 1), 'air_temp') air_h = ctrl.Antecedent(np.arange(0, 101, 1), 'air_humidity') s_moisture = ctrl.Antecedent(np.arange(0, 101, 1), 'soil_moisture') balance = ctrl.Antecedent(np.arange(0, 421, 1), 'balance') pumping = ctrl.Consequent(np.arange(0, 11, 1), 'pumping') # Cria manualmente o mapeamento entre valores nítidos e difusos s_moisture['dry'] = fuzz.trapmf(s_moisture.universe, [0, 0, 10, 22]) s_moisture['moderate'] = fuzz.trapmf(s_moisture.universe, [13, 22, 28, 37]) s_moisture['wet'] = fuzz.trapmf(s_moisture.universe, [28, 40, 100, 100]) air_h['low'] = fuzz.trapmf(air_h.universe, [0, 0, 70, 85]) air_h['high'] = fuzz.trapmf(air_h.universe, [75, 90, 100, 100]) air_temp['cool'] = fuzz.trapmf(air_temp.universe, [0, 0, 22, 34]) air_temp['hot'] = fuzz.trapmf(air_temp.universe, [22, 34, 50, 50]) balance['little'] = fuzz.trapmf(balance.universe, [0, 0, 120, 140]) balance['average'] = fuzz.trapmf(balance.universe, [120, 140, 280, 300]) balance['much'] = fuzz.trapmf(balance.universe, [280, 300, 420, 420]) pumping['veryshort'] = fuzz.trapmf(pumping.universe, [0, 0, 1, 3]) pumping['short'] = fuzz.trapmf(pumping.universe, [1, 3, 4, 6]) pumping['average'] = fuzz.trapmf(pumping.universe, [4, 6, 7, 9]) pumping['long'] = fuzz.trapmf(pumping.universe, [7, 9, 10, 10])
# fitnessValue = (dfFit['Asset'][len(dfFit)-1], yearstart, yearend, dfFit) fitnessValue = (dfFit['Asset'][len(dfFit) - 1], yearstart, yearend, dfFit.loc[len(dfFit) - 1, :]) return fitnessValue ############################################################################### ### Fuzzy one-time setup ############################################################################### # Set up RSI as an antecedent MA = ctrl.Antecedent(np.arange(-1000, 401, 1), 'MA') MA['low'] = fuzz.trapmf(MA.universe, [-1000, -1000, -60, -40]) MA['med'] = fuzz.trapmf(MA.universe, [-60, -40, 40, 60]) MA['high'] = fuzz.trapmf(MA.universe, [40, 60, 400, 400]) # Set up MACD as an antecedent MACD = ctrl.Antecedent(np.arange(-200, 201, 1), 'MACD') MACD['low'] = fuzz.trapmf(MACD.universe, [-200, -200, -15, -8]) MACD['med'] = fuzz.trapmf(MACD.universe, [-15, -8, 8, 15]) MACD['high'] = fuzz.trapmf(MACD.universe, [8, 15, 200, 200]) # Set up RSI as an antecedent RSI = ctrl.Antecedent(np.arange(0, 101, 1), 'RSI') RSI['low'] = fuzz.trapmf(RSI.universe, [0, 0, 30, 40]) RSI['med'] = fuzz.trapmf(RSI.universe, [30, 40, 60, 70]) RSI['high'] = fuzz.trapmf(RSI.universe, [60, 70, 100, 100])