import numpy as np import skfuzzy as fuzz from skfuzzy import control as ctrl f_qual = int(input("How did you liked the food ? [0-10] > ")) s_qual = int(input("How did you liked the service ? [0-10] > ")) quality = ctrl.Antecedent(np.arange(0, 11, 1), 'quality') service = ctrl.Antecedent(np.arange(0, 11, 1), 'service') tip = ctrl.Consequent(np.arange(0, 26, 1), 'tip') quality.automf(3) service.automf(3) tip['low'] = fuzz.trimf(tip.universe, [0, 0, 13]) tip['medium'] = fuzz.trimf(tip.universe, [0, 13, 25]) tip['high'] = fuzz.trimf(tip.universe, [13, 25, 25]) rule1 = ctrl.Rule(quality['poor'] | service['poor'], tip['low']) rule2 = ctrl.Rule(service['average'], tip['medium']) rule3 = ctrl.Rule(service['good'] | quality['good'], tip['high']) tipping_ctrl = ctrl.ControlSystem([rule1, rule2, rule3]) tipping = ctrl.ControlSystemSimulation(tipping_ctrl) tipping.input['quality'] = f_qual tipping.input['service'] = s_qual tipping.compute()
def ParteDifusa(VADIDF): # Los rangos que se va moaver las variable sujeto = ctrl.Antecedent(np.arange(0, 6, 1), 'sujeto') tiempo_verbal = ctrl.Antecedent(np.arange(0, 6, 1), 'tiempo_verbal') adjetivo = ctrl.Antecedent(np.arange(0, 6, 1), 'adjetivo') adverbio = ctrl.Antecedent(np.arange(0, 6, 1), 'adverbio') nivelAprendizajeIngles = ctrl.Consequent(np.arange(5, 21, 1), 'nivelAprendizajeIngles') sujeto['bajo'] = fuzz.trimf(sujeto.universe, [0, 0, 3]) sujeto['normal'] = fuzz.trimf(sujeto.universe, [2, 5, 5]) tiempo_verbal['bajo'] = fuzz.trimf(tiempo_verbal.universe, [0, 0, 3]) tiempo_verbal['normal'] = fuzz.trimf(tiempo_verbal.universe, [2, 5, 5]) adjetivo['bajo'] = fuzz.trimf(adjetivo.universe, [0, 0, 3]) adjetivo['normal'] = fuzz.trimf(adjetivo.universe, [2, 5, 5]) adverbio['bajo'] = fuzz.trimf(adverbio.universe, [0, 0, 3]) adverbio['normal'] = fuzz.trimf(adverbio.universe, [2, 5, 5]) nivelAprendizajeIngles['C'] = fuzz.trimf(nivelAprendizajeIngles.universe, [5, 5, 10]) nivelAprendizajeIngles['B'] = fuzz.trimf(nivelAprendizajeIngles.universe, [8, 12, 16]) nivelAprendizajeIngles['A'] = fuzz.trimf(nivelAprendizajeIngles.universe, [14, 16, 17]) nivelAprendizajeIngles['AD'] = fuzz.trimf(nivelAprendizajeIngles.universe, [16, 20, 20]) ################################################################################################# figVisualizacion =ctrl.fuzzyvariable.FuzzyVariableVisualizer(sujeto).view() figAnalisis =ctrl.fuzzyvariable.FuzzyVariableVisualizer(tiempo_verbal).view() figDeduccionInformal =ctrl.fuzzyvariable.FuzzyVariableVisualizer(adjetivo).view() figDeduccionFormal =ctrl.fuzzyvariable.FuzzyVariableVisualizer(adverbio).view() figNCG =ctrl.fuzzyvariable.FuzzyVariableVisualizer(nivelAprendizajeIngles).view() graph1_url = grafico_variable_fuzzy(figVisualizacion[0],"static/images/fuzzy/sujeto.jpg") graph2_url = grafico_variable_fuzzy(figAnalisis[0],"static/images/fuzzy/tiempo_verbal.jpg") graph3_url = grafico_variable_fuzzy(figDeduccionInformal[0],"static/images/fuzzy/adjetivo.jpg") graph4_url = grafico_variable_fuzzy(figDeduccionFormal[0],"static/images/fuzzy/adverbio.jpg") graph5_url = grafico_variable_fuzzy(figNCG[0],"static/images/fuzzy/nivelAprendizajeIngles.jpg") ################################################################################################# #-------reglas nivelAprendizajeIngles rule1 = ctrl.Rule(sujeto['bajo'] & tiempo_verbal['bajo'] & adjetivo['bajo'] & adverbio['bajo'], nivelAprendizajeIngles['C']) rule2 = ctrl.Rule(sujeto['bajo'] & tiempo_verbal['bajo'] & adjetivo['bajo'] & adverbio['normal'], nivelAprendizajeIngles['C']) rule3 = ctrl.Rule(sujeto['bajo'] & tiempo_verbal['bajo'] & adjetivo['normal'] & adverbio['bajo'], nivelAprendizajeIngles['C']) rule4 = ctrl.Rule(sujeto['bajo'] & tiempo_verbal['bajo'] & adjetivo['normal'] & adverbio['normal'], nivelAprendizajeIngles['C']) rule5 = ctrl.Rule(sujeto['bajo'] & tiempo_verbal['normal'] & adjetivo['bajo'] & adverbio['bajo'], nivelAprendizajeIngles['C']) rule6 = ctrl.Rule(sujeto['bajo'] & tiempo_verbal['normal'] & adjetivo['bajo'] & adverbio['normal'], nivelAprendizajeIngles['C']) rule7 = ctrl.Rule(sujeto['bajo'] & tiempo_verbal['normal'] & adjetivo['normal'] & adverbio['bajo'], nivelAprendizajeIngles['C']) rule8 = ctrl.Rule(sujeto['bajo'] & tiempo_verbal['normal'] & adjetivo['normal'] & adverbio['normal'], nivelAprendizajeIngles['C']) rule9 = ctrl.Rule(sujeto['normal'] & tiempo_verbal['bajo'] & adjetivo['bajo'] & adverbio['bajo'], nivelAprendizajeIngles['B']) rule10 = ctrl.Rule(sujeto['normal'] & tiempo_verbal['bajo'] & adjetivo['bajo'] & adverbio['normal'], nivelAprendizajeIngles['B']) rule11 = ctrl.Rule(sujeto['normal'] & tiempo_verbal['bajo'] & adjetivo['normal'] & adverbio['bajo'], nivelAprendizajeIngles['B']) rule12 = ctrl.Rule(sujeto['normal'] & tiempo_verbal['bajo'] & adjetivo['normal'] & adverbio['normal'], nivelAprendizajeIngles['B']) rule13 = ctrl.Rule(sujeto['normal'] & tiempo_verbal['normal'] & adjetivo['bajo'] & adverbio['bajo'], nivelAprendizajeIngles['B']) rule14 = ctrl.Rule(sujeto['normal'] & tiempo_verbal['normal'] & adjetivo['bajo'] & adverbio['normal'], nivelAprendizajeIngles['A']) rule15 = ctrl.Rule(sujeto['normal'] & tiempo_verbal['normal'] & adjetivo['normal'] & adverbio['bajo'], nivelAprendizajeIngles['A']) rule16 = ctrl.Rule(sujeto['normal'] & tiempo_verbal['normal'] & adjetivo['normal'] & adverbio['normal'], nivelAprendizajeIngles['AD']) acc_ctrl = ctrl.ControlSystem([rule1, rule2, rule3, rule4, rule5, rule6, rule7, rule8, rule9, rule10, rule11, rule12, rule13, rule14, rule15, rule16]) acc = ctrl.ControlSystemSimulation(acc_ctrl) #entradas al sistema acc.input['sujeto'] = VADIDF[0] acc.input['tiempo_verbal'] = VADIDF[1] acc.input['adjetivo'] = VADIDF[2] acc.input['adverbio'] = VADIDF[3] acc.compute() nivel_competencia = acc.output['nivelAprendizajeIngles'] print("nivel de Aprendizaje en Ingles: ",nivel_competencia) figNCG2 =ctrl.fuzzyvariable.FuzzyVariableVisualizer(nivelAprendizajeIngles).view(sim=acc) graph6_url = grafico_variable_fuzzy(figNCG2[0],"static/images/fuzzy/nivelAprendizajeIngles.jpg") return nivel_competencia
## Generate the dataset, save the data and a plot of it as well import numpy as np import skfuzzy as fuzz import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D from matplotlib import cm from skfuzzy import control as ctrl import scipy.io # Set for reproducibility np.random.seed(seed=123) loc_risk = ctrl.Antecedent(np.arange(0, 11, 1), 'loc_risk') maintenance = ctrl.Antecedent(np.arange(0, 11, 1), 'maintenance') downtime = ctrl.Consequent(np.arange(0, 101, 1), 'downtime') # Membership functions with parameters pre-specified. # Data would be generated from this fuzzy system # MCMC would be used later to identify whether the parameters of the fuzzy system can be recovered from the data. loc_risk['low'] = fuzz.trimf(loc_risk.universe, [0, 0, 5]) loc_risk['medium'] = fuzz.trimf(loc_risk.universe, [0, 5, 10]) loc_risk['high'] = fuzz.trimf(loc_risk.universe, [5, 10, 10]) maintenance['poor'] = fuzz.trimf(maintenance.universe, [0, 0, 5]) maintenance['average'] = fuzz.trimf(maintenance.universe, [0, 5, 10]) maintenance['good'] = fuzz.trimf(maintenance.universe, [5, 10, 10]) downtime['low'] = fuzz.trimf(downtime.universe, [0, 0, 50]) downtime['medium'] = fuzz.trimf(downtime.universe, [0, 50, 100]) downtime['high'] = fuzz.trimf(downtime.universe, [50, 100, 100])
#INITIAL CONDITIONS: Where is the quadcopter at the beginning of the simulation? ############################################################################## v0 = 0; u0 = 0; w0 = 0; x0 = 2.; y0 = 2.; theta0 = np.radians(0); ############################################################################## #SET TARGET: Where do you want the quadcopter to be? ############################################################################## target = [0, 5] # [x-coordinate, y-coordinate] ############################################################################## #FUZZY CONTROLLER ############################################################################## from skfuzzy import control as ctrl #Antecedents alt_error = ctrl.Antecedent(np.arange(-20, 20, .5), 'alt_error') alt_delta = ctrl.Antecedent(np.arange(-5, 5, .125), 'alt_delta') theta = ctrl.Antecedent(np.arange(-3.14, 3.14 ,.05), 'theta') omega = ctrl.Antecedent(np.arange(-3.14/4, 3.14/4 ,.05/4), 'omega') #Consequents force = ctrl.Consequent(np.arange(5.8, 13.8, .2), 'force') torque = ctrl.Consequent(np.arange(-3.14, 3.14, .05), 'torque') # Auto-membership function population is possible with .automf(3, 5, or 7) names = ['nb', 'ns', 'ze', 'ps', 'pb'] alt_error.automf(names=names) alt_delta.automf(names=names)
import numpy as np import skfuzzy as fuzz from skfuzzy import control as ctrl pendapatan = ctrl.Antecedent(np.arange(0, 3, 1), 'pendapatan') hutang = ctrl.Antecedent(np.arange(0, 100, 1), 'hutang') BLT = ctrl.Consequent(np.arange(0, 3, 1), 'BLT') pendapatan['rendah'] = fuzz.trimf(pendapatan.universe, [0, 0, 1]) pendapatan['sedang'] = fuzz.trimf(pendapatan.universe, [0, 1, 2]) pendapatan['tinggi'] = fuzz.trimf(pendapatan.universe, [1, 2, 2]) hutang['rendah'] = fuzz.trimf(hutang.universe, [0, 0, 49]) hutang['sedang'] = fuzz.trimf(hutang.universe, [0, 49, 98]) hutang['tinggi'] = fuzz.trimf(hutang.universe, [49, 98, 98]) BLT['tidak_layak'] = fuzz.trimf(BLT.universe, [0, 0, 0.5]) BLT['layak'] = fuzz.trimf(BLT.universe, [0.5, 1, 1]) rule1 = ctrl.Rule(pendapatan['rendah'] & hutang['rendah'], BLT['layak']) rule2 = ctrl.Rule(pendapatan['rendah'] & hutang['sedang'], BLT['layak']) rule3 = ctrl.Rule(pendapatan['rendah'] & hutang['tinggi'], BLT['layak']) rule4 = ctrl.Rule(pendapatan['sedang'] & hutang['rendah'], BLT['tidak_layak']) rule5 = ctrl.Rule(pendapatan['sedang'] & hutang['sedang'], BLT['tidak_layak']) rule6 = ctrl.Rule(pendapatan['sedang'] & hutang['tinggi'], BLT['layak']) rule7 = ctrl.Rule(pendapatan['tinggi'] & hutang['rendah'], BLT['tidak_layak']) rule8 = ctrl.Rule(pendapatan['tinggi'] & hutang['sedang'], BLT['tidak_layak']) rule9 = ctrl.Rule(pendapatan['tinggi'] & hutang['tinggi'], BLT['tidak_layak']) tipping_ctrl = ctrl.ControlSystem([rule1, rule2, rule3, rule4, rule5, rule6, rule7, rule8, rule9])
pos_l = fzy.trimf(posicao, [0, 0, 5]) pos_c = fzy.trimf(posicao, [4, 5, 6]) pos_r = fzy.trimf(posicao, [5, 10, 10]) # Direção: low = esquerda; medium = centro; high = direita direct_l = fzy.trimf(direcao, [0, 0, 5]) direct_m = fzy.trimf(direcao, [4, 5, 6]) direct_h = fzy.trimf(direcao, [5, 10, 10]) # Velocidade de saida: low = baixa; medium = normal; high = alta vel_sa_l = fzy.trapmf(velocidade_saida, [0, 0, 2, 4]) vel_sa_m = fzy.trimf(velocidade_saida, [3, 5, 7]) vel_sa_h = fzy.trapmf(velocidade_saida, [6, 8, 10, 10]) # Define as entradas e saidas do sistema velocidade_entrada = ctrl.Antecedent(velocidade_entrada, "Velocidade de Entrada") proximidade = ctrl.Antecedent(proximidade, "Proximidade") posicao = ctrl.Antecedent(posicao, "Posição") direcao = ctrl.Consequent(direcao, "Direção") velocidade_saida = ctrl.Consequent(velocidade_saida, "Velocidade de Saida") # Faixa de valores para utilizar nas regras velocidade_entrada["Baixa"] = vel_en_l velocidade_entrada["Normal"] = vel_en_m velocidade_entrada["Alta"] = vel_en_h proximidade["Perto"] = pro_c proximidade["Normal"] = pro_m proximidade["Longe"] = pro_f posicao["Esquerda"] = pos_l
import numpy as np import skfuzzy as fuzz from skfuzzy import control as ctrl # Cria as variáveis do problema comida = ctrl.Antecedent(np.arange(0, 26, 1), 'comida') servico = ctrl.Antecedent(np.arange(0, 11, 1), 'servico') gorjeta = ctrl.Consequent(np.arange(0, 26, 1), 'gorjeta') # Cria as funções de pertinência usando tipos variados servico['ruim'] = fuzz.trimf(servico.universe, [0, 0, 5]) servico['aceitável'] = fuzz.gaussmf(servico.universe, 5, 2) servico['excelente'] = fuzz.gaussmf(servico.universe, 10, 3) comida['péssima'] = fuzz.trapmf(comida.universe, [0, 7, 12, 15]) comida['comível'] = fuzz.trapmf(comida.universe, [13, 16, 18, 20]) comida['deliciosa'] = fuzz.trapmf(comida.universe, [17, 20, 23, 25]) gorjeta['baixa'] = fuzz.trimf(gorjeta.universe, [0, 0, 13]) gorjeta['média'] = fuzz.trapmf(gorjeta.universe, [0, 13, 15, 25]) gorjeta['alta'] = fuzz.trimf(gorjeta.universe, [15, 25, 25]) comida.view() servico.view() gorjeta.view() #Regras rule1 = ctrl.Rule(servico['excelente'] | comida['deliciosa'], gorjeta['alta']) rule2 = ctrl.Rule(servico['aceitável'], gorjeta['média']) rule3 = ctrl.Rule(servico['ruim'] & comida['péssima'], gorjeta['baixa'])
def init_fuzzy(self): """ Make fuzzy setup by defining membership functions and rules """ # Set the difference between the right front sensor and the right back sensor difference_right_sensors = ctrl.Antecedent(np.arange(-1.0, 1.0, 0.001), 'difference_right_sensors') difference_right_sensors['negative'] = fuzz.trimf( difference_right_sensors.universe, [-1.0, -1.0, 0.0]) difference_right_sensors['zero'] = fuzz.trimf( difference_right_sensors.universe, [-0.015, 0.0, 0.015]) difference_right_sensors['positive'] = fuzz.trimf( difference_right_sensors.universe, [0.0, 1.0, 1.0]) # Set the distances of the front sensors distances_front_sensors = list() for i in range(3): distances_front_sensors.append( ctrl.Antecedent(np.arange(0, 5.0, self.steps), 'distance_front_sensor_' + str(i + 1))) distances_front_sensors[i]['close'] = fuzz.trapmf( distances_front_sensors[i].universe, [0.0, 0.0, 0.3, 0.8]) distances_front_sensors[i]['away'] = fuzz.trapmf( distances_front_sensors[i].universe, [0.3, 0.8, 5.0, 5.0]) # Define available velocities for each wheel v_left = ctrl.Consequent( np.arange(-self.max_speed, 1.0 + self.max_speed, 0.01), 'vl') v_right = ctrl.Consequent( np.arange(-self.max_speed, 1.0 + self.max_speed, 0.01), 'vr') # Define the membership functions for the wheels speed v_left['fast'] = fuzz.trimf(v_left.universe, [2.0, 2.0, self.max_speed]) v_left['regular'] = fuzz.trimf(v_left.universe, [0.0, 2.0, 2.0]) v_left['zero'] = fuzz.trimf(v_left.universe, [-0.1, 0.0, 0.1]) v_right['fast'] = fuzz.trimf(v_right.universe, [2.0, 2.0, self.max_speed]) v_right['regular'] = fuzz.trimf(v_left.universe, [0.0, 2.0, 2.0]) v_right['zero'] = fuzz.trimf(v_right.universe, [-0.1, 0.0, 0.1]) # Rules to make the robot follow the wall by turning left, right or going forward # Turn left rule_l1 = ctrl.Rule( distances_front_sensors[0]['close'] | distances_front_sensors[1]['close'] | distances_front_sensors[2]['close'], v_left['zero']) rule_r1 = ctrl.Rule( distances_front_sensors[0]['close'] | distances_front_sensors[1]['close'] | distances_front_sensors[2]['close'], v_right['fast']) # Turn right rule_l2 = ctrl.Rule( difference_right_sensors['positive'] & distances_front_sensors[0]['away'] & distances_front_sensors[1]['away'], v_left['fast']) rule_r2 = ctrl.Rule(difference_right_sensors['positive'], v_right['zero']) # Go forward, next to the wall rule_l3 = ctrl.Rule( difference_right_sensors['zero'] & distances_front_sensors[0]['away'] & distances_front_sensors[1]['away'], v_left['regular']) rule_r3 = ctrl.Rule( difference_right_sensors['zero'] & distances_front_sensors[0]['away'] & distances_front_sensors[1]['away'], v_right['regular']) rule_l4 = ctrl.Rule( difference_right_sensors['negative'] & distances_front_sensors[0]['away'] & distances_front_sensors[1]['away'], v_left['regular']) rule_r4 = ctrl.Rule( difference_right_sensors['negative'] & distances_front_sensors[0]['away'] & distances_front_sensors[1]['away'], v_right['regular']) vel_ctrl = ctrl.ControlSystem([ rule_l1, rule_l2, rule_l3, rule_l4, rule_r1, rule_r2, rule_r3, rule_r4 ]) self.fuzzy_system = ctrl.ControlSystemSimulation(vel_ctrl)
import numpy as np import skfuzzy as fuzz from skfuzzy import control as ctrl # antecedentes servicio = ctrl.Antecedent(np.arange(0, 10, 1), 'servicio') calidad = ctrl.Antecedent(np.arange(0, 10, 1), 'calidad') propina = ctrl.Consequent(np.arange(0, 10, 1), 'propina') # funciones de pertenencia automaticas servicio.automf(3); calidad['bajo'] = fuzz.trapmf(calidad.universe, [0,0, 1, 5]) calidad['medio'] = fuzz.trapmf(calidad.universe, [2, 3, 6, 7]) calidad['alto'] = fuzz.trapmf(calidad.universe, [5, 8, 10, 10]) # graficar las funciones de pertenencia servicio.view() calidad.view() # consecuente propina['bajo'] = fuzz.trapmf(calidad.universe, [0,0, 1, 5]) propina['medio'] = fuzz.trapmf(calidad.universe, [2, 3, 6, 7]) propina['alto'] = fuzz.trapmf(calidad.universe, [5, 8, 10, 10]) # graficar las funciones de pertenencia
def veg_cap_fis(model_run): """ Vegetation capacity fis function :param model_run: The model being run, either 'Hpe' or 'ex" :return: """ arcpy.env.overwriteOutput = True # get list of all fields in the flowline network fields = [f.name for f in arcpy.ListFields(in_network)] # set the carrying capacity and vegetation field depending on whether potential or existing run if model_run == 'Hpe': out_field = "oVC_Hpe" riparian_field = "iVeg100Hpe" streamside_field = "iVeg_30Hpe" else: out_field = "oVC_EX" riparian_field = "iVeg100EX" streamside_field = "iVeg_30EX" # check for oVC_* field in the network attribute table and delete if exists if out_field in fields: arcpy.DeleteField_management(in_network, out_field) # get arrays for fields of interest segid_np = arcpy.da.FeatureClassToNumPyArray(in_network, "ReachID") riparian_np = arcpy.da.FeatureClassToNumPyArray( in_network, riparian_field) streamside_np = arcpy.da.FeatureClassToNumPyArray( in_network, streamside_field) segid_array = np.asarray(segid_np, np.int64) riparian_array = np.asarray(riparian_np, np.float64) streamside_array = np.asarray(streamside_np, np.float64) # check that inputs are within range of fis # if not, re-assign the value to just within range riparian_array[riparian_array < 0] = 0 riparian_array[riparian_array > 4] = 4 streamside_array[streamside_array < 0] = 0 streamside_array[streamside_array > 4] = 4 # delete temp arrays items = [segid_np, riparian_np, streamside_np] for item in items: del item # create antecedent (input) and consequent (output) objects to hold universe variables and membership functions riparian = ctrl.Antecedent(np.arange(0, 4, 0.01), 'input1') streamside = ctrl.Antecedent(np.arange(0, 4, 0.01), 'input2') density = ctrl.Consequent(np.arange(0, 45, 0.01), 'result') # build membership functions for each antecedent and consequent object riparian['unsuitable'] = fuzz.trapmf(riparian.universe, [0, 0, 0.1, 1]) riparian['barely'] = fuzz.trimf(riparian.universe, [0.1, 1, 2]) riparian['moderately'] = fuzz.trimf(riparian.universe, [1, 2, 3]) riparian['suitable'] = fuzz.trimf(riparian.universe, [2, 3, 4]) riparian['preferred'] = fuzz.trimf(riparian.universe, [3, 4, 4]) streamside['unsuitable'] = fuzz.trapmf(streamside.universe, [0, 0, 0.1, 1]) streamside['barely'] = fuzz.trimf(streamside.universe, [0.1, 1, 2]) streamside['moderately'] = fuzz.trimf(streamside.universe, [1, 2, 3]) streamside['suitable'] = fuzz.trimf(streamside.universe, [2, 3, 4]) streamside['preferred'] = fuzz.trimf(streamside.universe, [3, 4, 4]) density['none'] = fuzz.trimf(density.universe, [0, 0, 0.1]) density['rare'] = fuzz.trapmf(density.universe, [0, 0.1, 0.5, 1.5]) density['occasional'] = fuzz.trapmf(density.universe, [0.5, 1.5, 4, 8]) density['frequent'] = fuzz.trapmf(density.universe, [4, 8, 12, 25]) density['pervasive'] = fuzz.trapmf(density.universe, [12, 25, 45, 45]) # build fis rule table rule1 = ctrl.Rule(riparian['unsuitable'] & streamside['unsuitable'], density['none']) rule2 = ctrl.Rule(riparian['barely'] & streamside['unsuitable'], density['rare']) rule3 = ctrl.Rule(riparian['moderately'] & streamside['unsuitable'], density['rare']) rule4 = ctrl.Rule(riparian['suitable'] & streamside['unsuitable'], density['occasional']) rule5 = ctrl.Rule(riparian['preferred'] & streamside['unsuitable'], density['occasional']) rule6 = ctrl.Rule(riparian['unsuitable'] & streamside['barely'], density['rare']) # matBRAT has consequent as 'occasional' rule7 = ctrl.Rule(riparian['barely'] & streamside['barely'], density['rare']) rule8 = ctrl.Rule(riparian['moderately'] & streamside['barely'], density['occasional']) rule9 = ctrl.Rule(riparian['suitable'] & streamside['barely'], density['occasional']) rule10 = ctrl.Rule(riparian['preferred'] & streamside['barely'], density['occasional']) rule11 = ctrl.Rule(riparian['unsuitable'] & streamside['moderately'], density['rare']) rule12 = ctrl.Rule(riparian['barely'] & streamside['moderately'], density['occasional']) rule13 = ctrl.Rule(riparian['moderately'] & streamside['moderately'], density['occasional']) rule14 = ctrl.Rule(riparian['suitable'] & streamside['moderately'], density['frequent']) rule15 = ctrl.Rule(riparian['preferred'] & streamside['moderately'], density['frequent']) rule16 = ctrl.Rule(riparian['unsuitable'] & streamside['suitable'], density['occasional']) rule17 = ctrl.Rule(riparian['barely'] & streamside['suitable'], density['occasional']) rule18 = ctrl.Rule(riparian['moderately'] & streamside['suitable'], density['frequent']) rule19 = ctrl.Rule(riparian['suitable'] & streamside['suitable'], density['frequent']) rule20 = ctrl.Rule(riparian['preferred'] & streamside['suitable'], density['pervasive']) rule21 = ctrl.Rule(riparian['unsuitable'] & streamside['preferred'], density['occasional']) rule22 = ctrl.Rule(riparian['barely'] & streamside['preferred'], density['frequent']) rule23 = ctrl.Rule(riparian['moderately'] & streamside['preferred'], density['pervasive']) rule24 = ctrl.Rule(riparian['suitable'] & streamside['preferred'], density['pervasive']) rule25 = ctrl.Rule(riparian['preferred'] & streamside['preferred'], density['pervasive']) # FIS veg_ctrl = ctrl.ControlSystem([ rule1, rule2, rule3, rule4, rule5, rule6, rule7, rule8, rule9, rule10, rule11, rule12, rule13, rule14, rule15, rule16, rule17, rule18, rule19, rule20, rule21, rule22, rule23, rule24, rule25 ]) veg_fis = ctrl.ControlSystemSimulation(veg_ctrl) # run fuzzy inference system on inputs and defuzzify output out = np.zeros(len(riparian_array)) for i in range(len(out)): veg_fis.input['input1'] = riparian_array[i] veg_fis.input['input2'] = streamside_array[i] veg_fis.compute() out[i] = veg_fis.output['result'] # save fuzzy inference system output as table columns = np.column_stack((segid_array, out)) # TODO See if possible to skip this step out_table = os.path.dirname( in_network) + "/" + out_field + "_Table.txt" np.savetxt(out_table, columns, delimiter=",", header="ReachID, " + out_field, comments="") ovc_table = scratch + "/" + out_field + "Tbl" arcpy.CopyRows_management(out_table, ovc_table) # join the fuzzy inference system output to the flowline network # create empty dictionary to hold input table field values tbl_dict = {} # add values to dictionary with arcpy.da.SearchCursor(ovc_table, ['ReachID', out_field]) as cursor: for row in cursor: tbl_dict[row[0]] = row[1] # populate flowline network out field arcpy.AddField_management(in_network, out_field, 'DOUBLE') with arcpy.da.UpdateCursor(in_network, ['ReachID', out_field]) as cursor: for row in cursor: try: a_key = row[0] row[1] = tbl_dict[a_key] cursor.updateRow(row) # TODO There should be no blank exception statements. What error is this catching? except: pass tbl_dict.clear() # calculate defuzzified centroid value for density 'none' MF group # this will be used to re-classify output values that fall in this group # important: will need to update the array (x) and MF values (mfx) if the # density 'none' values are changed in the model x = np.arange(0, 45, 0.01) mfx_none = fuzz.trimf(x, [0, 0, 0.1]) defuzz_none = round(fuzz.defuzz(x, mfx_none, 'centroid'), 6) mfx_pervasive = fuzz.trapmf(x, [12, 25, 45, 45]) defuzz_pervasive = round(fuzz.defuzz(x, mfx_pervasive, 'centroid')) # update vegetation capacity (ovc_*) values in stream network # set ovc_* to 0 if output falls fully in 'none' category and to 40 if falls fully in 'pervasive' category with arcpy.da.UpdateCursor(in_network, [out_field]) as cursor: for row in cursor: if round(row[0], 6) == defuzz_none: row[0] = 0.0 if round(row[0]) >= defuzz_pervasive: row[0] = 40.0 cursor.updateRow(row) # delete temporary tables and arrays arcpy.Delete_management(out_table) arcpy.Delete_management(ovc_table) items = [columns, out, x, mfx_none, defuzz_none] for item in items: del item
pygame.display.set_caption("intersect") ballorg = 250 count = 0 running = True threadlist = [] lineAmmount = 8 incrementLine = 360 / lineAmmount rot = 0 global q q = queue() closeness = ctrl.Antecedent((np.arange(0, 500, 1)), "Closeness") meteorCount = ctrl.Antecedent(np.arange(0, 50, 1), "Meteors") danger = ctrl.Consequent(np.arange(0, 100, 1), "Danger") meteorCount['lots'] = fuzz.trapmf(meteorCount.universe, [30, 50, 100, 100]) meteorCount['many'] = fuzz.trimf(meteorCount.universe, [15, 40, 100]) meteorCount['few'] = fuzz.trimf(meteorCount.universe, [0, 10, 20]) closeness['close'] = fuzz.trimf(closeness.universe, [0, 100, 200]) closeness['distant'] = fuzz.trimf(closeness.universe, [100, 250, 400]) closeness['far'] = fuzz.trimf(closeness.universe, [350, 500, 500]) danger['low'] = fuzz.trimf(danger.universe, [0, 0, 30]) danger['med'] = fuzz.trimf(danger.universe, [20, 50, 100]) danger['high'] = fuzz.trimf(danger.universe, [75, 100, 100])
def computeQuality(self, M1_level, M2_level): #INPUT------------------------------------------------------------------------- M1 = ctrl.Antecedent(np.arange(0, 1.0, 0.01), 'M1 level') M2 = ctrl.Antecedent(np.arange(0, 1.0, 0.01), 'M2 level') #OUTPUT------------------------------------------------------------------------- BikeWay = ctrl.Consequent(np.arange(0, 1.0, 0.01), 'BikeWay') #SET DEFINITION----------------------------------------------------------------- M1.automf(names=['Very Good', 'Good', 'Moderate', 'Bad', 'Very Bad']) M2.automf(names=['Very Good', 'Good', 'Moderate', 'Bad', 'Very Bad']) BikeWay.automf( names=['Very Good', 'Good', 'Moderate', 'Bad', 'Very Bad']) #RULES-------------------------------------------------------------------------- rule1 = ctrl.Rule(M1['Very Bad'] | M2['Very Bad'], BikeWay['Very Bad']) rule2 = ctrl.Rule(((M1['Bad'] & (M2['Bad'] | M2['Moderate'])) | (M1['Moderate'] & M2['Bad'])), BikeWay['Bad']) rule3 = ctrl.Rule(((M1['Bad'] & (M2['Good'] | M2['Very Good'])) | (M1['Moderate'] & M2['Moderate']) | ((M1['Good'] | M1['Very Good']) & M2['Bad'])), BikeWay['Moderate']) rule4 = ctrl.Rule(((M1['Moderate'] & (M2['Good'] | M2['Very Good'])) | (M1['Good'] & (M2['Moderate'] | M2['Good'])) | (M1['Very Good'] & M2['Moderate'])), BikeWay['Good']) rule5 = ctrl.Rule( ((M1['Good'] | M1['Very Good']) & (M2['Good'] | M2['Very Good'])), BikeWay['Very Good']) BikeWay_control = ctrl.ControlSystem( [rule1, rule2, rule3, rule4, rule5]) BikeWay_simulator = ctrl.ControlSystemSimulation(BikeWay_control) BikeWay_simulator.input['M1 level'] = M1_level BikeWay_simulator.input['M2 level'] = M2_level BikeWay_simulator.compute() BikeWay_level = BikeWay_simulator.output['BikeWay'] M1Quality = self.numericToName(M1_level) M2Quality = self.numericToName(M2_level) bikeWayQuality = "Very Bad" if (M1Quality == "Bad" and (M2Quality == 'Bad' or M2Quality == 'Moderate')) or ( M1Quality == "Moderate" and M2Quality == 'Bad'): bikeWayQuality = "Bad" elif (M1Quality == "Bad" and (M2Quality == "Good" or M2Quality == "Very Good")) or ( M1Quality == "Moderate" and M2Quality == "Moderate") or ( (M1Quality == "Good" or M1Quality == "Very Good") and M2Quality == "Bad"): bikeWayQuality = "Moderate" elif (M1Quality == "Moderate" and (M2Quality == "Good" or M2Quality == "Very Good")) or ( M1Quality == "Good" and (M2Quality == "Moderate" or M2Quality == "Good")) or ( M1Quality == "Very Good" and M2Quality == "Moderate"): bikeWayQuality = "Good" elif (M1Quality == "Good" or M1Quality == "Very Good") and (M2Quality == "Good" or M2Quality == "Very Good"): bikeWayQuality = "Very Good" print(" M1 quality = " + M1Quality) print(" M2 quality = " + M2Quality) print(" BikeWay quality = " + bikeWayQuality + " (" + str(BikeWay_level) + ")") #BikeWay.view(sim=BikeWay_simulator) #plt.show() return self.encodeQuality(bikeWayQuality)
def fuzzy_val_generator(light_level_in, temp_level_in): # Input and Output array declaration light_level = ctrl.Antecedent( np.arange(0, 21, 1), 'light_level') # should change the range according to the sensor value temp_level = ctrl.Antecedent( np.arange(0, 21, 1), 'temp_level') # should change the range according to the sensor value power_level_for_light = ctrl.Consequent( np.arange(0, 11, 1), 'power_level_for_light' ) # should change the range according to the sensor value power_level_for_temp = ctrl.Consequent( np.arange(0, 11, 1), 'power_level_for_temp' ) # should change the range according to the sensor value # Auto membership function population light_level.automf(3) # poor, average, good temp_level.automf(3) power_level_for_light.automf(3) power_level_for_temp.automf(3) # rules initialization rule1 = ctrl.Rule( light_level['poor'] & temp_level['poor'], (power_level_for_light['good'], power_level_for_temp['good'])) rule2 = ctrl.Rule( light_level['poor'] & temp_level['average'], (power_level_for_light['good'], power_level_for_temp['average'])) rule3 = ctrl.Rule( light_level['poor'] & temp_level['good'], (power_level_for_light['good'], power_level_for_temp['poor'])) rule4 = ctrl.Rule( light_level['average'] & temp_level['poor'], (power_level_for_light['average'], power_level_for_temp['good'])) rule5 = ctrl.Rule( light_level['average'] & temp_level['average'], (power_level_for_light['average'], power_level_for_temp['average'])) rule6 = ctrl.Rule( light_level['average'] & temp_level['good'], (power_level_for_light['average'], power_level_for_temp['poor'])) rule7 = ctrl.Rule( light_level['good'] & temp_level['poor'], (power_level_for_light['poor'], power_level_for_temp['good'])) rule8 = ctrl.Rule( light_level['good'] & temp_level['average'], (power_level_for_light['poor'], power_level_for_temp['average'])) rule9 = ctrl.Rule( light_level['good'] & temp_level['good'], (power_level_for_light['poor'], power_level_for_temp['poor'])) # Control system and simulation power_ctrl = ctrl.ControlSystem( [rule1, rule2, rule3, rule4, rule5, rule6, rule7, rule8, rule9]) power = ctrl.ControlSystemSimulation(power_ctrl) power.input['light_level'] = light_level_in power.input['temp_level'] = temp_level_in power.compute() return power.output['power_level_for_light'], power.output[ 'power_level_for_temp']
def create_function(self): self.opinion = ctrl.Antecedent(self.opinion_universe, 'opinion') self.emotion = ctrl.Antecedent(self.emotion_universe, 'emotion') self.time = ctrl.Antecedent(self.time_universe, 'time') self.rules = ctrl.Antecedent(self.rules_universe, 'rules')
import numpy as np import skfuzzy as fuzz from skfuzzy import control people = control.Antecedent(np.arange(0, 300, 1), 'people') tech_supplies = control.Antecedent(np.arange(0, 500, 1), 'tech_supplies') skill = control.Antecedent(np.arange(0, 100, 1), 'skill') productivity = control.Consequent(np.arange(0, 100, 1), 'productivity') cost = control.Consequent(np.arange(0, 100, 1), 'cost') tech_supplies_demand = control.Consequent(np.arange(0, 100, 1), 'tech_supplies_demand') tech_supplies.automf(3) skill.automf(3) productivity.automf(3) cost.automf(5) people.automf(3) tech_supplies_demand.automf(3) tech_supplies_demand_rule_1 = control.Rule(tech_supplies['poor'] & people['average'], tech_supplies_demand['average']) tech_supplies_demand_rule_2 = control.Rule(tech_supplies['average'] & people['good'], tech_supplies_demand['average']) tech_supplies_demand_rule_3 = control.Rule(tech_supplies['poor'] & people['good'], tech_supplies_demand['good']) tech_supplies_demand_rule_4 = control.Rule(tech_supplies['good'], tech_supplies_demand['poor']) tech_supplies_demand_rule_5 = control.Rule(tech_supplies['average'] & people['average'], tech_supplies_demand['poor']) tech_supplies_demand_rule_6 = control.Rule(people['poor'], tech_supplies_demand['poor'])
import skfuzzy as fuzz import numpy as np import skfuzzy.control as ctrl import matplotlib.pyplot as plt x_dhumi_range = np.arange(-6, 101, 1, np.float32) x_hc_range = np.arange(-1, 6, 1, np.float32) y_output_range = np.arange(0, 101, 1, np.float32) # 创建模糊控制变量 x_dhumi = ctrl.Antecedent(x_dhumi_range, 'dhumi') x_hc = ctrl.Antecedent(x_hc_range, 'hc') y_output = ctrl.Consequent(y_output_range, 'output') # 定义模糊集和其隶属度函数 x_dhumi['N'] = fuzz.trimf(x_dhumi_range, [-6, -6, 47]) x_dhumi['M'] = fuzz.trimf(x_dhumi_range, [-6, 47,100]) x_dhumi['P'] = fuzz.trimf(x_dhumi_range, [47, 100, 100]) x_hc['N'] = fuzz.trimf(x_hc_range, [-1, -1, 2]) x_hc['M'] = fuzz.trimf(x_hc_range, [-1, 2, 5]) x_hc['P'] = fuzz.trimf(x_hc_range, [2, 5, 5]) y_output['N'] = fuzz.trimf(y_output_range, [0, 0, 50]) y_output['M'] = fuzz.trimf(y_output_range, [0, 50, 100]) y_output['P'] = fuzz.trimf(y_output_range, [50, 100, 100]) # 设定输出output的解模糊方法——质心解模糊方式 y_output.defuzzify_method = 'centroid'
# Fuzzy Logic Potted Plant Conditions Rating # Author: Wojciech Kudłacik and Norbert Daniluk # Inspiration: https://pythonhosted.org/scikit-fuzzy/auto_examples/plot_tipping_problem_newapi.html import matplotlib.pyplot as plt import numpy as np import skfuzzy as fuzz from skfuzzy import control as ctrl ''' List of inputs They hold universe values and membership functions ''' temperature = ctrl.Antecedent(np.arange(10, 31, 1), 'temperature') luminosity = ctrl.Antecedent(np.arange(2500, 10001, 100), 'luminosity') soil_moisture = ctrl.Antecedent(np.arange(0, 11, 1), 'soil_moisture') ''' List of outputs They hold universe values and membership functions ''' condition_rating = ctrl.Consequent(np.arange(0, 11, 1), 'condition_rating') ''' Inputs membership functions population In this case functions are populated automatically using .automf function ''' temperature.automf(3) luminosity.automf(3) soil_moisture.automf(3) '''
def oraculo(detectionzone, contenedor): global zonadeteccion zonadeteccion = detectionzone PERSON_CERCA = (zonadeteccion.area / 1000) * 0.10 PERSON_MEDIO = (zonadeteccion.area / 1000) * 0.06 PERSON_LEJOS = (zonadeteccion.area / 1000) * 0.02 CAR_CERCA = (zonadeteccion.area / 1000) * 0.20 CAR_MEDIO = (zonadeteccion.area / 1000) * 0.12 CAR_LEJOS = (zonadeteccion.area / 1000) * 0.05 print("Personas") print(cuentaPersonas(contenedor)) print(personasIzquierda(contenedor)) print(personasCentro(contenedor)) print(personasDerecha(contenedor)) print(zonadeteccion.area) print(PERSON_CERCA) print(PERSON_MEDIO) print(PERSON_LEJOS) print("Coches") print(cuentaCoches(contenedor)) print(cochesIzquierda(contenedor)) print(cochesCentro(contenedor)) print(cochesDerecha(contenedor)) print(zonadeteccion.area) print(CAR_CERCA) print(CAR_MEDIO) print(CAR_LEJOS) ##--------------------------## ## FUZZY ## ##--------------------------## in_p_names = ['lejos', 'medio', 'cerca'] p_izquierda = ctrl.Antecedent(np.arange(0, PERSON_CERCA + 1, 1), 'p_izquierda') p_centro = ctrl.Antecedent(np.arange(0, PERSON_CERCA + 1, 1), 'p_centro') p_derecha = ctrl.Antecedent(np.arange(0, PERSON_CERCA + 1, 1), 'p_derecha') p_izquierda.automf(names=in_p_names) p_centro.automf(names=in_p_names) p_derecha.automf(names=in_p_names) p_izquierda['lejos'] = p_centro['lejos'] = p_derecha[ 'lejos'] = fuzz.trapmf(p_derecha.universe, [0, 0, (PERSON_LEJOS - 2), PERSON_LEJOS]) p_izquierda['medio'] = p_centro['medio'] = p_derecha[ 'medio'] = fuzz.trapmf(p_derecha.universe, [(PERSON_LEJOS - 2), PERSON_LEJOS, (PERSON_MEDIO - 2), PERSON_MEDIO]) p_izquierda[ 'cerca'] = p_centro['cerca'] = p_derecha['cerca'] = fuzz.trapmf( p_derecha.universe, [(PERSON_MEDIO - 2), PERSON_MEDIO, PERSON_CERCA, PERSON_CERCA]) in_c_names = ['lejos', 'medio', 'cerca'] c_izquierda = ctrl.Antecedent(np.arange(0, CAR_CERCA + 1, 1), 'c_izquierda') c_centro = ctrl.Antecedent(np.arange(0, CAR_CERCA + 1, 1), 'c_centro') c_derecha = ctrl.Antecedent(np.arange(0, CAR_CERCA + 1, 1), 'c_derecha') c_izquierda.automf(names=in_c_names) c_centro.automf(names=in_c_names) c_derecha.automf(names=in_c_names) c_izquierda['lejos'] = c_centro['lejos'] = c_derecha[ 'lejos'] = fuzz.trapmf(c_derecha.universe, [0, 0, (CAR_LEJOS - 2), CAR_LEJOS]) c_izquierda['medio'] = c_centro['medio'] = c_derecha[ 'medio'] = fuzz.trapmf(c_derecha.universe, [(CAR_LEJOS - 2), CAR_LEJOS, (CAR_MEDIO - 2), CAR_MEDIO]) c_izquierda[ 'cerca'] = c_centro['cerca'] = c_derecha['cerca'] = fuzz.trapmf( c_derecha.universe, [(CAR_MEDIO - 2), CAR_MEDIO, CAR_CERCA, CAR_CERCA]) out_d_names = [ 'mucho_izquierda', 'medio_izquierda', 'neutro', 'medio_derecha', 'mucho_derecha' ] direccion = ctrl.Consequent(np.arange(0, 181, 1), 'direccion') direccion.automf(names=out_d_names) direccion['mucho_izquierda'] = fuzz.trapmf(direccion.universe, [0, 0, 35, 40]) direccion['medio_izquierda'] = fuzz.trapmf(direccion.universe, [35, 40, 70, 75]) direccion['neutro'] = fuzz.trapmf(direccion.universe, [70, 75, 105, 110]) direccion['medio_derecha'] = fuzz.trapmf(direccion.universe, [105, 110, 140, 145]) direccion['mucho_derecha'] = fuzz.trapmf(direccion.universe, [140, 145, 180, 180]) out_f_names = ['leve', 'medio', 'fuerte'] frenada = ctrl.Consequent(np.arange(0, 101, 1), 'frenada') frenada.automf(names=out_f_names) frenada['leve'] = fuzz.trapmf(frenada.universe, [0, 0, 16, 20]) frenada['medio'] = fuzz.trapmf(frenada.universe, [16, 20, 35, 40]) frenada['fuerte'] = fuzz.trapmf(frenada.universe, [35, 40, 100, 100]) ## ------------------------------------------ //CONTROL VOLANTE\\ ------------------------------------------ ## d_rule1 = ctrl.Rule(antecedent=((p_izquierda['cerca']) & (p_centro['medio'] | p_centro['lejos'])), consequent=direccion['mucho_derecha']) d_rule2 = ctrl.Rule(antecedent=((p_izquierda['medio']) & (p_centro['medio'] | p_centro['lejos'])), consequent=direccion['medio_derecha']) d_rule3 = ctrl.Rule( antecedent=(((p_izquierda['lejos'] & p_derecha['lejos']) | p_centro['cerca'])), consequent=direccion['neutro']) d_rule4 = ctrl.Rule(antecedent=((p_derecha['medio']) & (p_centro['medio'] | p_centro['lejos'])), consequent=direccion['medio_izquierda']) d_rule5 = ctrl.Rule(antecedent=((p_derecha['cerca']) & (p_centro['medio'] | p_centro['lejos'])), consequent=direccion['mucho_izquierda']) d_rule6 = ctrl.Rule(antecedent=((c_izquierda['cerca']) & (c_centro['medio'] | c_centro['lejos'])), consequent=direccion['mucho_derecha']) d_rule7 = ctrl.Rule(antecedent=((c_izquierda['medio']) & (c_centro['medio'] | c_centro['lejos'])), consequent=direccion['medio_derecha']) d_rule8 = ctrl.Rule( antecedent=(((c_izquierda['lejos'] & c_derecha['lejos']) | c_centro['cerca'])), consequent=direccion['neutro']) d_rule9 = ctrl.Rule(antecedent=((c_derecha['medio']) & (c_centro['medio'] | c_centro['lejos'])), consequent=direccion['medio_izquierda']) d_rule10 = ctrl.Rule(antecedent=((c_derecha['cerca']) & (c_centro['medio'] | c_centro['lejos'])), consequent=direccion['mucho_izquierda']) ctrl_volante = ctrl.ControlSystem(rules=[ d_rule1, d_rule2, d_rule3, d_rule4, d_rule5, d_rule6, d_rule7, d_rule8, d_rule9, d_rule10 ]) volante = ctrl.ControlSystemSimulation(ctrl_volante) volante.input['p_izquierda'] = personasIzquierda(contenedor) volante.input['p_centro'] = personasCentro(contenedor) volante.input['p_derecha'] = personasDerecha(contenedor) volante.input['c_izquierda'] = cochesIzquierda(contenedor) volante.input['c_centro'] = cochesCentro(contenedor) volante.input['c_derecha'] = cochesDerecha(contenedor) volante.compute() print("PREDICCION VOLANTE: ") print(volante.output['direccion']) ## ------------------------------------------ \\CONTROL VOLANTE// ------------------------------------------ ## ## --------------------------------------------------------------------------------------------------------- ## ## ------------------------------------------ //CONTROL FRENADA\\ ------------------------------------------ ## f_rule1 = ctrl.Rule( antecedent=((p_izquierda['cerca']) | (p_centro['cerca']) | (p_derecha['cerca'])), consequent=frenada['fuerte']) f_rule2 = ctrl.Rule( antecedent=((p_izquierda['medio']) | (p_centro['medio']) | (p_derecha['medio'])), consequent=frenada['medio']) f_rule3 = ctrl.Rule( antecedent=((p_izquierda['lejos']) | (p_centro['lejos']) | (p_derecha['lejos'])), consequent=frenada['leve']) f_rule4 = ctrl.Rule( antecedent=((c_izquierda['cerca']) | (c_centro['cerca']) | (c_derecha['cerca'])), consequent=frenada['fuerte']) f_rule5 = ctrl.Rule( antecedent=((c_izquierda['medio']) | (c_centro['medio']) | (c_derecha['medio'])), consequent=frenada['medio']) f_rule6 = ctrl.Rule( antecedent=((c_izquierda['lejos']) | (c_centro['lejos']) | (c_derecha['lejos'])), consequent=frenada['leve']) ctrl_freno = ctrl.ControlSystem( rules=[f_rule1, f_rule2, f_rule3, f_rule4, f_rule5, f_rule6]) freno = ctrl.ControlSystemSimulation(ctrl_freno) freno.input['p_izquierda'] = personasIzquierda(contenedor) freno.input['p_centro'] = personasCentro(contenedor) freno.input['p_derecha'] = personasDerecha(contenedor) freno.input['c_izquierda'] = cochesIzquierda(contenedor) freno.input['c_centro'] = cochesCentro(contenedor) freno.input['c_derecha'] = cochesDerecha(contenedor) freno.compute() print("PREDICCION FRENADA: ") print(freno.output['frenada']) ## ------------------------------------------ \\CONTROL FRENADA// ------------------------------------------ ## return volante.output['direccion'], freno.output['frenada']
import numpy as np import skfuzzy as fuzz from skfuzzy import control as ctrl # Cria as variáveis do problema temp = ctrl.Antecedent(np.arange(0, 41, 1), 'temp') u_ar = ctrl.Antecedent(np.arange(0, 101, 1), 'u_ar') u_solo = ctrl.Antecedent(np.arange(0, 1025, 1), 'u_solo') saldo = ctrl.Antecedent(np.arange(0, 101, 1), 'saldo') irrig = ctrl.Consequent(np.arange(30, 101, 30), 'irrig') # Cria automaticamente o mapeamento entre valores nítidos e difusos # usando uma função de pertinência (triângulo) temp['frio'] = fuzz.trimf(temp.universe, [0, 0, 20]) temp['agradavel'] = fuzz.trapmf(temp.universe, [10, 21, 22, 35]) temp['quente'] = fuzz.trimf(temp.universe, [22, 40, 40]) u_ar['seco'] = fuzz.trapmf(u_ar.universe, [0, 0, 40, 60]) u_ar['medio'] = fuzz.trapmf(u_ar.universe, [35, 60, 65, 80]) u_ar['umido'] = fuzz.trimf(u_ar.universe, [65, 100, 100]) u_solo['seco'] = fuzz.gaussmf(u_solo.universe, 0, 256) u_solo['medio'] = fuzz.gaussmf(u_solo.universe, 512, 256) u_solo['umido'] = fuzz.gaussmf(u_solo.universe, 1024, 256) saldo['pouco'] = fuzz.trimf(saldo.universe, [0, 0, 20]) saldo['muito'] = fuzz.trimf(saldo.universe, [0, 100, 100])
import skfuzzy as fuzz from skfuzzy import control as ctrl import matplotlib.pyplot as plt def wall_follow(dist): distance_left = min(dist[:4]) distance_right = min(dist[4:]) walking.input['distance left'] = distance_left walking.input['distance right'] = distance_right walking.compute() return [walking.output['velocity left'], walking.output['velocity right']] distance_left = ctrl.Antecedent(np.arange(0.2, 5.01, 0.01), 'distance left') distance_right = ctrl.Antecedent(np.arange(0.2, 5.01, 0.01), 'distance right') velocity_left = ctrl.Consequent(np.arange(0.0, 5.1, 0.1), 'velocity left') velocity_right = ctrl.Consequent(np.arange(0.0, 5.1, 0.1), 'velocity right') distance_left['low'] = fuzz.trimf(distance_left.universe, [0.2, 0.2, 0.3]) distance_left['medium'] = fuzz.trimf(distance_left.universe, [0.2, 0.3, 1.0]) distance_left['high'] = fuzz.trapmf(distance_left.universe, [0.5, 1.0, 5.0, 5.0]) distance_right['low'] = fuzz.trimf(distance_right.universe, [0.2, 0.2, 0.3]) distance_right['medium'] = fuzz.trimf(distance_right.universe, [0.2, 0.3, 1.0]) distance_right['high'] = fuzz.trapmf(distance_right.universe, [0.5, 1.0, 5.0, 5.0])
Logica y Teoria de la Computacion Dany Rubiano Jimenez 22.250.855-k """ import numpy as np import skfuzzy as fuzz from skfuzzy import control as ctrl ############################################# Antecedentes ############################################# ####### Factores de empaquetadura: # Nivel esfuerzo empaque (incluye factores como cantidad de productos, cantidad de bolsas, entre otros) # Tiempo (Tiempo que demora en terminar una vez el cliente esta listo) esfuerzo = ctrl.Antecedent(np.arange(0, 8, 0.1), 'Nivel de esfuerzo del empaque') # tiempo_empaque = ctrl.Antecedent( np.arange(0, 10, 0.1), 'Tiempo de empaque' ) # Tiempo que demora el empaque en terminar, despues que termina de pagar el cliente ####### Factores externos: # Nivel de atención cajera (como una nota de 1 a 7, que mide factores de tiempo, amabilidad y otros) # Tiempo de espera en fila (medido en minutos) atencion_cajera = ctrl.Antecedent(np.arange(0, 7, 0.1), 'Nivel de atencion cajera') tiempo_espera = ctrl.Antecedent( np.arange(0, 30, 0.1), 'Tiempo de espera en fila' ) # Cuanto tiempo se esta en la fila esperando atencion ####### Factores internos:
# np.arange(min, max, step) : step will influence accuracy (esp. curve e.g. Gaussian MF) step_meter = 0.02 # If the step are large, the Gaussian MF will regress to Triangular MF step_meter_per_second = 0.02 step_risk = 1 range_degree = np.arange( -180, 180 + 1, 1.0) # Range: -180 degree ~ 180 degree for direction and orientation range_meter = np.arange(0, 3.0 + step_meter, step_meter) # Range: 0 meter ~ 3 meter for distance range_meter_per_second = np.arange( -1.0, 2.0 + step_meter_per_second, step_meter_per_second) #Range: -1.0 mps ~ 2 mps for speed range_risk = np.arange(0, 5 + step_risk, step_risk) # Range: 0,1,2,3,4 for risk object_distance = ctrl.Antecedent(range_meter, 'distance') # 0- 3 meter object_direction = ctrl.Antecedent(range_degree, 'direction') # -180~180 degree object_risk = ctrl.Antecedent(range_risk, 'risk') left_speed = ctrl.Consequent(range_meter_per_second, 'left') right_speed = ctrl.Consequent(range_meter_per_second, 'right') # Custom membership functions can be built interactively with a familiar Pythonic API #distance_p1 = fuzz.gaussmf(range_meter,IZW,0.1) #distance_p2 = fuzz.gaussmf(range_meter,IZW,0.1) # Distance object_distance['Near'] = fuzz.trapmf( range_meter, [0, 0, IZW, 2 * IZW] ) #fuzz.gaussmf(range_meter,0.5*IZW,0.1) # skfuzzy.membership.gaussmf(x, mean, sigma) object_distance['Medium'] = fuzz.trimf(
import numpy as np import skfuzzy as fuzz from skfuzzy import control as ctrl pendapatan = ctrl.Antecedent(np.arange(0, 50, 5), 'pendapatan') nilaiUN = ctrl.Antecedent(np.arange(0, 11, 1), 'nilaiUN') kelayakan = ctrl.Consequent(np.arange(0, 101, 5), 'kelayakan') pendapatan.automf(3) nilaiUN.automf(3) pendapatan['poor'] = fuzz.trapmf(pendapatan.universe, [0, 0, 5, 15]) pendapatan['average'] = fuzz.trimf(pendapatan.universe, [10, 20, 30]) pendapatan['good'] = fuzz.trapmf(pendapatan.universe, [25, 35, 50, 50]) pendapatan.view() nilaiUN['poor'] = fuzz.trapmf(nilaiUN.universe, [0, 0, 4, 6]) nilaiUN['average'] = fuzz.trimf(nilaiUN.universe, [5, 6, 8]) nilaiUN['good'] = fuzz.trapmf(nilaiUN.universe, [7, 9, 10, 10]) nilaiUN.view() kelayakan['low'] = fuzz.trapmf(kelayakan.universe, [0, 0, 20, 70]) kelayakan['high'] = fuzz.trapmf(kelayakan.universe, [50, 90, 100, 100]) kelayakan.view() rule1 = ctrl.Rule(pendapatan['poor'] & nilaiUN['good'], kelayakan['high']) rule2 = ctrl.Rule(pendapatan['average'] & nilaiUN['good'], kelayakan['high']) rule3 = ctrl.Rule(pendapatan['good'] & nilaiUN['good'], kelayakan['low']) rule4 = ctrl.Rule(pendapatan['poor'] & nilaiUN['average'], kelayakan['high']) rule5 = ctrl.Rule(pendapatan['average'] & nilaiUN['average'], kelayakan['low']) rule6 = ctrl.Rule(pendapatan['good'] & nilaiUN['average'], kelayakan['low'])
Użytkownik na samym początku podaję swoje dane jak wiek, długość czas posiadanego prawa jazdy i ilość mieszkańców , w którym żyje. ''' age_val = int(input("Podaj swój wiek : ")) experience_val = int(input("Ile lat posiadasz swoje prawo jazdy? : ")) city_populacion_val = int(input("Podaj ilość mieszkańców twojego miasta : ")) ''' Określenie danych wejściowych i wyjściowych wygląda następująco: - wiek w zakresię od 18 do 56 lat. Powyżej tego zakresu składka je staję się niezmiennia - czas posiadania prawa jazdy, który mieści się w zakresie do 31 lat - (wyjście) skala od 0 do 100. Im możliwie korzystne ubecpieczenie tym blizej 100 . ''' # definiujemy membership funcions zaczynając od danyczah wejściowych i kończąc na wyjściowych age = ctrl.Antecedent(np.arange(18, 56, 1), 'age') experience = ctrl.Antecedent(np.arange(0, 31, 1), 'experience') city_populacion = ctrl.Antecedent(np.arange(0, 500001, 1), 'city_populacion') indicator = ctrl.Consequent(np.arange(0, 101, 1), 'indicator') # definiujemy kształt naszych funkcji wejściowych. Dzielimy wiek na : # young, adult, old age['young'] = fuzz.trimf(age.universe, [18, 25, 35]) age['adult'] = fuzz.trimf(age.universe, [25, 35, 45]) age['old'] = fuzz.trimf(age.universe, [35, 45, 55]) experience['beginner'] = fuzz.trimf(experience.universe, [0, 0, 15]) experience['intermediate'] = fuzz.trimf(experience.universe, [0, 15, 30]) experience['advanced'] = fuzz.trimf(experience.universe, [15, 30, 30]) city_populacion['small'] = fuzz.trimf(city_populacion.universe, [0, 0, 20000])
#importing libraries import numpy as np import skfuzzy as fuzz from skfuzzy import control as ctrl import matplotlib #configuring input and output variables range_of_y = 1000 y=ctrl.Antecedent(np.arange(0,range_of_y+0.1,0.01),'lateral lane displacement') range_of_acc= 300 y_acc=ctrl.Antecedent(np.arange(0,range_of_acc,0.001),'lateral accelaration') error=100 e=ctrl.Antecedent(np.arange(-error,error,0.1),'error') y['first']=fuzz.trapmf(y.universe,[0,range_of_y/16,3*range_of_y/16,4*range_of_y/16]) y['second']=fuzz.trapmf(y.universe,[5*range_of_y/16,6*range_of_y/16,7*range_of_y/16,8*range_of_y/16]) y['third']=fuzz.trapmf(y.universe,[9*range_of_y/16,10*range_of_y/16,11*range_of_y/16,12*range_of_y/16]) y['final']=fuzz.trapmf(y.universe,[13*range_of_y/16,14*range_of_y/16,15*range_of_y/16,16*range_of_y/16]) y_acc['GT0']=fuzz.trimf(y_acc.universe,[1,range_of_acc/2,range_of_acc]) y_acc['GE0']=fuzz.trimf(y_acc.universe,[0,range_of_acc/2,range_of_acc]) y_acc['LTM']=fuzz.trimf(y_acc.universe,[-range_of_acc,0,range_of_acc-1]) y_acc['GEM']=fuzz.trimf(y_acc.universe,[range_of_acc,range_of_acc,range_of_acc]) y_acc['GT-M']=fuzz.trimf(y_acc.universe,[-range_of_acc+1,0,range_of_acc]) y_acc['LE-M']=fuzz.trimf(y_acc.universe,[-range_of_acc,-range_of_acc,-range_of_acc]) y_acc['LT0']=fuzz.trimf(y_acc.universe,[-range_of_acc,-range_of_acc/2,-1]) y_acc['LE0']=fuzz.trimf(y_acc.universe,[-range_of_acc,-range_of_acc/2,0]) e['N']=fuzz.trimf(e.universe,[-error,-error,-1]) e['Z']=fuzz.trimf(e.universe,[-error/2,0,error/2]) e['P']=fuzz.trimf(e.universe,[1,error,error]) stear_angle=0.006 angle=ctrl.Consequent(np.arange(-stear_angle,stear_angle,0.0001),'stear_angle') angle['s1']=fuzz.trimf(angle.universe,[0,0.0006/2,0.0006])
#inputs a_direcao.input['distanciaF'] = frente a_direcao.input['distanciaE'] = esquerda a_direcao.input['distanciaD'] = direita # Crunch the numbers a_direcao.compute() return (a_direcao.output['direcao'], a_direcao.output['velocidade']) posicao_x = [] posicao_y = [] #variaveis fuzzy direcao = ctrl.Consequent(np.arange(0, 11, 1), 'direcao') velocidade = ctrl.Consequent(np.arange(0, 11, 1), 'velocidade') distanciaF = ctrl.Antecedent(np.arange(0, 11, 1), 'distanciaF') distanciaD = ctrl.Antecedent(np.arange(0, 11, 1), 'distanciaD') distanciaE = ctrl.Antecedent(np.arange(0, 11, 1), 'distanciaE') v_mp = [0, 0, 3] v_p = [0, 3, 5] v_m = [0, 5, 10] v_l = [5, 8, 10] v_ml = [8, 10, 10] distanciaF['mperto'] = fuzz.trimf(distanciaF.universe, v_mp) distanciaF['perto'] = fuzz.trimf(distanciaF.universe, v_p) distanciaF['medio'] = fuzz.trimf(distanciaF.universe, v_m) distanciaF['longe'] = fuzz.trimf(distanciaF.universe, v_ml) distanciaD['mperto'] = fuzz.trimf(distanciaD.universe, v_mp)
def __init__(self): # first we need to design the membership functions # The arrival membership function # assign the bounds of the membership function arrivals = ctrl.Antecedent(np.arange(0, 16, 1), 'arrivals') # assign the bounds of every fuzzy member arrivals["AN"] = fuzz.trimf(arrivals.universe, [0, 0, 2]) arrivals["F"] = fuzz.trimf(arrivals.universe, [1, 4, 7]) arrivals["MY"] = fuzz.trimf(arrivals.universe, [5, 9, 13]) arrivals["TMY"] = fuzz.trimf(arrivals.universe, [10, 15, 15]) # the queue membership function # assign the bounds of the queue membership function queue = ctrl.Antecedent(np.arange(0, 16, 1), 'queue') # assign the the bounds of each fuzzy member queue["VS"] = fuzz.trimf(queue.universe, [0, 0, 2]) queue["S"] = fuzz.trimf(queue.universe, [1, 4, 7]) queue["M"] = fuzz.trimf(queue.universe, [5, 9, 13]) queue["L"] = fuzz.trimf(queue.universe, [10, 15, 15]) # the extension membership function # assign the bounds of the extension membership function extension = ctrl.Consequent(np.arange(0, 7, 1), 'extension') # assign the bounds of each fuzzy member extension["Z"] = fuzz.trimf(extension.universe, [0, 0, 2]) extension["SO"] = fuzz.trimf(extension.universe, [0, 2, 4]) extension["ML"] = fuzz.trimf(extension.universe, [2, 4, 6]) extension["LO"] = fuzz.trimf(extension.universe, [4, 6, 6]) self.extension = extension # implement all the rules available rule1 = ctrl.Rule(arrivals["AN"] & queue["VS"], extension["Z"]) rule2 = ctrl.Rule(arrivals["AN"] & queue["S"], extension["Z"]) rule3 = ctrl.Rule(arrivals["AN"] & queue["M"], extension["Z"]) rule4 = ctrl.Rule(arrivals["AN"] & queue["L"], extension["Z"]) rule5 = ctrl.Rule(arrivals["F"] & queue["VS"], extension["SO"]) rule6 = ctrl.Rule(arrivals["F"] & queue["S"], extension["SO"]) rule7 = ctrl.Rule(arrivals["F"] & queue["M"], extension["Z"]) rule8 = ctrl.Rule(arrivals["F"] & queue["L"], extension["Z"]) rule9 = ctrl.Rule(arrivals["MY"] & queue["VS"], extension["ML"]) rule10 = ctrl.Rule(arrivals["MY"] & queue["S"], extension["ML"]) rule11 = ctrl.Rule(arrivals["MY"] & queue["M"], extension["SO"]) rule12 = ctrl.Rule(arrivals["MY"] & queue["L"], extension["Z"]) rule13 = ctrl.Rule(arrivals["TMY"] & queue["VS"], extension["LO"]) rule14 = ctrl.Rule(arrivals["TMY"] & queue["S"], extension["ML"]) rule15 = ctrl.Rule(arrivals["TMY"] & queue["M"], extension["ML"]) rule16 = ctrl.Rule(arrivals["TMY"] & queue["L"], extension["SO"]) # implement the control system that does the fuzzification, composition inference and defuzzification for us traffic_lights_ctrl = ctrl.ControlSystem(rules=[ rule1, rule2, rule3, rule4, rule5, rule6, rule7, rule8, rule9, rule10, rule11, rule12, rule13, rule14, rule15, rule16 ]) if graphs: extension.view() arrivals.view() queue.view() traffic_lights_ctrl.view() self.traffic_lights_simulation = ctrl.ControlSystemSimulation( traffic_lights_ctrl)
import numpy as np import skfuzzy as fuzz from skfuzzy import control as ctrl import matplotlib.pyplot as plt temp = ctrl.Antecedent(np.arange(0, 101, 1), 'temp') clock_speed = ctrl.Antecedent(np.arange(0, 4.5, 0.5), 'clock_speed') fan_speed = ctrl.Consequent(np.arange(0, 6001, 1), 'fan_speed') temp['cold'] = fuzz.trimf(temp.universe, [0, 0, 50]) temp['warm'] = fuzz.trimf(temp.universe, [30, 50, 70]) temp['hot'] = fuzz.trimf(temp.universe, [50, 100, 100]) clock_speed['low'] = fuzz.trimf(clock_speed.universe, [0, 0, 1.5]) clock_speed['normal'] = fuzz.trimf(clock_speed.universe, [0.5, 2, 3.5]) clock_speed['turbo'] = fuzz.trimf(clock_speed.universe, [2.5, 4, 4]) fan_speed['slow'] = fuzz.trimf(fan_speed.universe, [0, 0, 3500]) fan_speed['fast'] = fuzz.trimf(fan_speed.universe, [2500, 6000, 6000]) temp.view() clock_speed.view() fan_speed.view() rules = [] rule1 = ctrl.Rule(temp['cold'] & clock_speed['low'], fan_speed['slow']) rule2 = ctrl.Rule(temp['cold'] & clock_speed['normal'], fan_speed['slow']) rule3 = ctrl.Rule(temp['cold'] & clock_speed['turbo'], fan_speed['fast']) rule4 = ctrl.Rule(temp['warm'] & clock_speed['low'], fan_speed['slow']) rule5 = ctrl.Rule(temp['warm'] & clock_speed['normal'], fan_speed['slow']) rule6 = ctrl.Rule(temp['warm'] & clock_speed['turbo'], fan_speed['fast'])
def test_multiple_rules_same_consequent_term(): # 2 input variables, 1 output variable and 7 instances. x1_inputs = [0.6, 0.2, 0.4, 0.7, 1, 1.2, 1.8] x2_inputs = [0.9, 1, 0.8, 0, 1.2, 0.6, 1.8] dom = np.arange(0, 2.1, 0.01) x1 = ctrl.Antecedent(dom, "x1") x1['label0'] = fuzz.trimf(x1.universe, (0.2, 0.2, 0.6)) x1['label1'] = fuzz.trimf(x1.universe, (0.2, 0.6, 1.0)) x1['label2'] = fuzz.trimf(x1.universe, (0.6, 1.0, 1.4)) x1['label3'] = fuzz.trimf(x1.universe, (1.0, 1.4, 1.8)) x1['label4'] = fuzz.trimf(x1.universe, (1.4, 1.8, 1.8)) x2 = ctrl.Antecedent(dom, "x2") x2['label0'] = fuzz.trimf(x2.universe, (0.0, 0.0, 0.45)) x2['label1'] = fuzz.trimf(x2.universe, (0.0, 0.45, 0.9)) x2['label2'] = fuzz.trimf(x2.universe, (0.45, 0.9, 1.35)) x2['label3'] = fuzz.trimf(x2.universe, (0.9, 1.35, 1.8)) x2['label4'] = fuzz.trimf(x2.universe, (1.35, 1.8, 1.8)) y = ctrl.Consequent(dom, "y") y['label0'] = fuzz.trimf(y.universe, (0.3, 0.3, 0.725)) y['label1'] = fuzz.trimf(y.universe, (0.3, 0.725, 1.15)) y['label2'] = fuzz.trimf(y.universe, (0.725, 1.15, 1.575)) y['label3'] = fuzz.trimf(y.universe, (1.15, 1.575, 2.0)) y['label4'] = fuzz.trimf(y.universe, (1.575, 2.0, 2.0)) r1 = ctrl.Rule(x1['label0'] & x2['label2'], y['label0']) r2 = ctrl.Rule(x1['label1'] & x2['label0'], y['label0']) r3 = ctrl.Rule(x1['label1'] & x2['label2'], y['label0']) # Equivalent to above 3 rules r123 = ctrl.Rule( (x1['label0'] & x2['label2']) | (x1['label1'] & x2['label0']) | (x1['label1'] & x2['label2']), y['label0']) r4 = ctrl.Rule(x1['label2'] & x2['label1'], y['label2']) r5 = ctrl.Rule(x1['label2'] & x2['label3'], y['label3']) r6 = ctrl.Rule(x1['label4'] & x2['label4'], y['label4']) # Build a system with three rules targeting the same Consequent Term, # and then an equivalent system with those three rules combined into one. cs0 = ctrl.ControlSystem([r1, r2, r3, r4, r5, r6]) cs1 = ctrl.ControlSystem([r123, r4, r5, r6]) expected_results = [ 0.438372093023, 0.443962536855, 0.461436409933, 0.445290345769, 1.575, 1.15, 1.86162790698 ] # Ensure the results are equivalent within error for inst, expected in zip(range(7), expected_results): sim0 = ctrl.ControlSystemSimulation(cs0) sim1 = ctrl.ControlSystemSimulation(cs1) sim0.input["x1"] = x1_inputs[inst] sim0.input["x2"] = x2_inputs[inst] sim1.input["x1"] = x1_inputs[inst] sim1.input["x2"] = x2_inputs[inst] sim0.compute() sim1.compute() tst.assert_allclose(sim0.output['y'], sim1.output['y']) tst.assert_allclose(expected, sim0.output['y'], atol=1e-4, rtol=1e-4)
import numpy as np import skfuzzy as fuzz from skfuzzy import control as ctrl import matplotlib.pyplot as plt #variable pan_temp = ctrl.Antecedent(np.arange(0, 121, 0.5), 'pan_temp') pan_weight = ctrl.Antecedent(np.arange(0, 3.1, 0.1), 'pan_weight') heat_level = ctrl.Consequent(np.arange(0, 121, 0.5), 'heat_level') #membership function pan_temp['cold'] = fuzz.trimf(pan_temp.universe, [0, 0, 45]) pan_temp['warm'] = fuzz.trimf(pan_temp.universe, [30, 60, 90]) pan_temp['hot'] = fuzz.trimf(pan_temp.universe, [75, 105, 120]) pan_weight['low'] = fuzz.trimf(pan_weight.universe, [0, 0, 1.0]) pan_weight['medium'] = fuzz.trimf(pan_weight.universe, [0.5, 1.25, 2.0]) pan_weight['high'] = fuzz.trimf(pan_weight.universe, [1.5, 2.25, 3.0]) heat_level['low'] = fuzz.trimf(heat_level.universe, [0, 0, 60]) heat_level['medium'] = fuzz.trimf(heat_level.universe, [20, 60, 100]) heat_level['high'] = fuzz.trimf(heat_level.universe, [60, 100, 120]) pan_temp.view() pan_weight.view() heat_level.view() plt.show() #rules r1 = ctrl.Rule(pan_temp['cold'] & pan_weight['low'], heat_level['medium']) r2 = ctrl.Rule(pan_temp['cold'] & pan_weight['medium'], heat_level['medium'])