import numpy as np
import skfuzzy as fuzz
from skfuzzy import control as ctrl
import matplotlib.pyplot as plt
value_PWM_x_serv = ctrl.Consequent(np.arange(-100, 101, 1), 'value_PWM_x_serv')
# value_PWM_y_serv = ctrl.Consequent(np.arange(-100, 101, 1), 'value_PWM_y_serv')
x_error = ctrl.Antecedent(np.arange(-200, 201, 1), 'x_error')
# y_error = ctrl.Antecedent(np.arange(-200, 201, 1), 'y_error')
value_PWM_x_serv['low'] = fuzz.trapmf(value_PWM_x_serv.universe,
[-100, -100, -20, 0])
value_PWM_x_serv['medium'] = fuzz.trimf(value_PWM_x_serv.universe,
[-20, 0, 20])
value_PWM_x_serv['high'] = fuzz.trapmf(value_PWM_x_serv.universe,
[0, 20, 100, 100])
# value_PWM_x_serv.view()
# value_PWM_y_serv['low'] = fuzz.trapmf(value_PWM_y_serv.universe, [-100,-100, -20, 0])
# value_PWM_y_serv['medium'] = fuzz.trimf(value_PWM_y_serv.universe, [-20, 0, 20])
# value_PWM_y_serv['high'] = fuzz.trapmf(value_PWM_y_serv.universe, [0, 20 ,100 ,100])
# value_PWM_y_serv.view()
x_error['poor'] = fuzz.trapmf(x_error.universe, [-200, -200, -150, 0])
x_error['average'] = fuzz.trimf(x_error.universe, [-150, 0, 150])
x_error['good'] = fuzz.trapmf(x_error.universe, [0, 150, 200, 200])
# x_error.view()
# y_error['poor'] = fuzz.trapmf(y_error.universe, [-200,-200,-150, 0])
# y_error['average'] = fuzz.trimf(y_error.universe, [-150, 0, 150])
# Fuzzy Control System - Tipping Problem import numpy as np import matplotlib.pyplot as plt import skfuzzy as fuzz from skfuzzy import control as ctrl # Antecedent = input # Consequent = output 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') # Auto-membership function population 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]) # You can see how these look with .view() quality['average'].view() plt.show() service.view() plt.show() tip.view() plt.show()
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]) # Set up Trading Volume as a consequent volume = ctrl.Consequent(np.arange(-10, 11, 1), 'volume') volume['sell'] = fuzz.trapmf(volume.universe, [-10, -10, -6, -5]) volume['hold'] = fuzz.trapmf(volume.universe, [-6, -5, 5, 6]) volume['buy'] = fuzz.trapmf(volume.universe, [5, 6, 10, 10]) #____________________________________________________________________ # Set up the Buy/Sell/Hold rules rule01 = ctrl.Rule(MA['low'] & MACD['low'] & RSI['low'], volume['sell']) rule02 = ctrl.Rule(MA['low'] & MACD['low'] & RSI['med'], volume['sell']) rule03 = ctrl.Rule(MA['low'] & MACD['low'] & RSI['high'], volume['sell']) rule04 = ctrl.Rule(MA['low'] & MACD['med'] & RSI['low'], volume['hold']) rule05 = ctrl.Rule(MA['low'] & MACD['med'] & RSI['med'], volume['sell']) rule06 = ctrl.Rule(MA['low'] & MACD['med'] & RSI['high'], volume['sell']) rule07 = ctrl.Rule(MA['low'] & MACD['high'] & RSI['low'], volume['buy']) rule08 = ctrl.Rule(MA['low'] & MACD['high'] & RSI['med'], volume['hold'])
from skfuzzy import control as ctrl
def sqrt(num):
return num**0.5
def square(num):
return num**2
# Generate semesta dari fuzzy set sebagai numpy array
suhu = ctrl.Antecedent(np.arange(15, 36, 1), 'suhu')
lembab = ctrl.Antecedent(np.arange(0, 101, 1), 'lembab')
orang = ctrl.Antecedent(np.arange(0, 31, 1), 'orang')
thermostat = ctrl.Consequent(np.arange(15, 36, 1), 'thermostat')
#Generate nilai-nilai membership function dengan trimf untuk membuat triangular membership function
suhu['rendah'] = fuzz.trimf(suhu.universe, [15, 15, 25])
suhu['sedang'] = fuzz.trimf(suhu.universe, [23, 25, 29])
suhu['tinggi'] = fuzz.trimf(suhu.universe, [27, 35, 36])
lembab['rendah'] = fuzz.trimf(lembab.universe, [0, 0, 41])
lembab['sedang'] = fuzz.trimf(lembab.universe, [35, 55, 76])
lembab['tinggi'] = fuzz.trimf(lembab.universe, [70, 100, 101])
orang['sedikit'] = fuzz.trimf(orang.universe, [0, 0, 21])
orang['banyak'] = fuzz.trimf(orang.universe, [10, 30, 31])
thermostat['agak rendah'] = np.array(
list(map(sqrt, fuzz.trimf(suhu.universe, [15, 15, 25]))))
thermostat['rendah'] = fuzz.trimf(suhu.universe, [15, 15, 25])
thermostat['sangat rendah'] = np.array(
list(map(square, fuzz.trimf(suhu.universe, [15, 15, 25]))))
def fuzzy_factor(self, bufferT, diffBufferT):
T = self.T
d = self.d #DeltaTime
# Cria as variáveis do problema
bufferTime = ctrl.Antecedent(np.arange(0, 4 * T, 0.01), 'bufferTime')
diffBufferTime = ctrl.Antecedent(
np.arange((-2) * d, (4 * d) + 10, 0.005), 'diffBufferTime')
bitratefactor = ctrl.Consequent(np.arange(0, 2.5, 0.01),
'bitratefactor')
# Cria automaticamente o mapeamento entre valores nítidos e difusos
# usando uma função de pertinência padrão (triângulo)
bufferTime['short'] = fuzz.trapmf(bufferTime.universe,
[0, 0, (2 * T) / 3, T])
bufferTime['close'] = fuzz.trimf(bufferTime.universe,
[(2 * T) / 3, T, 4 * T])
bufferTime['long'] = fuzz.trapmf(bufferTime.universe,
[T, 4 * T, 10 * T, 10 * T])
# Cria as funções de pertinência usando tipos variados
diffBufferTime['falling'] = fuzz.trapmf(
diffBufferTime.universe, [-120, -120, ((-2) * d) / 3, 0])
diffBufferTime['steady'] = fuzz.trimf(diffBufferTime.universe,
[((-2) * d) / 3, 0, 4 * d])
diffBufferTime['rising'] = fuzz.trapmf(diffBufferTime.universe,
[0, 4 * d, 10 * d, 10 * d])
N2 = 0.25
N1 = 0.5
Z = 1
P1 = 1.5
P2 = 2
bitratefactor['reduce'] = fuzz.trapmf(bitratefactor.universe,
[0, 0, N2, N1])
bitratefactor['small reduce'] = fuzz.trimf(bitratefactor.universe,
[N2, N1, Z])
bitratefactor['no change'] = fuzz.trimf(bitratefactor.universe,
[N1, Z, P1])
bitratefactor['small increase'] = fuzz.trimf(bitratefactor.universe,
[Z, P1, P2])
bitratefactor['increase'] = fuzz.trapmf(bitratefactor.universe,
[P1, P2, 2.5, 2.5])
rule1 = ctrl.Rule(bufferTime['short'] & diffBufferTime['falling'],
bitratefactor['reduce'])
rule2 = ctrl.Rule(bufferTime['close'] & diffBufferTime['falling'],
bitratefactor['small reduce'])
rule3 = ctrl.Rule(bufferTime['long'] & diffBufferTime['falling'],
bitratefactor['no change'])
rule4 = ctrl.Rule(bufferTime['short'] & diffBufferTime['steady'],
bitratefactor['small reduce'])
rule5 = ctrl.Rule(bufferTime['close'] & diffBufferTime['steady'],
bitratefactor['no change'])
rule6 = ctrl.Rule(bufferTime['long'] & diffBufferTime['steady'],
bitratefactor['small increase'])
rule7 = ctrl.Rule(bufferTime['short'] & diffBufferTime['rising'],
bitratefactor['no change'])
rule8 = ctrl.Rule(bufferTime['close'] & diffBufferTime['rising'],
bitratefactor['small increase'])
rule9 = ctrl.Rule(bufferTime['long'] & diffBufferTime['rising'],
bitratefactor['increase'])
bitratefactor_ctrl = ctrl.ControlSystem(
[rule1, rule2, rule3, rule4, rule5, rule6, rule7, rule8, rule9])
bitratefactor_simulador = ctrl.ControlSystemSimulation(
bitratefactor_ctrl)
# Entrando com alguns valores para qualidade da comida e do serviço
# Eixo X do gráfico
bitratefactor_simulador.input['bufferTime'] = bufferT
bitratefactor_simulador.input['diffBufferTime'] = diffBufferT
# Computando o resultado
bitratefactor_simulador.compute()
print("BitrateAtual * ",
bitratefactor_simulador.output['bitratefactor'])
"""
#Gera 3 graficos quando buffir_size = 50
import matplotlib.pyplot as plt
if bufferT == 50:
bufferTime.view(sim=bitratefactor_simulador)
diffBufferTime.view(sim=bitratefactor_simulador)
bitratefactor.view(sim=bitratefactor_simulador)
plt.show()
"""
return bitratefactor_simulador.output['bitratefactor']
def comb_cap_fis(in_network, model_run, scratch, max_da_thresh):
"""
The combined capacity FIS function
:param in_network: The input BRAT network
:param model_run: The model being run, either 'Hpe' or 'ex" (Potential or Existing)
:param scratch: The current workspace
:param max_da_thresh: The drainage area value above which the stream is assumed to not support dam building
: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 = "oCC_HPE"
veg_field = "oVC_HPE"
mcc_field = "mCC_HPE_CT"
else:
out_field = "oCC_EX"
veg_field = "oVC_EX"
mcc_field = "mCC_EX_CT"
# check for oCC_* 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")
ovc_np = arcpy.da.FeatureClassToNumPyArray(in_network, veg_field)
ihydsp2_np = arcpy.da.FeatureClassToNumPyArray(in_network, "iHyd_SP2")
ihydsplow_np = arcpy.da.FeatureClassToNumPyArray(in_network, "iHyd_SPLow")
igeoslope_np = arcpy.da.FeatureClassToNumPyArray(in_network, "iGeo_Slope")
segid_array = np.asarray(segid_np, np.int64)
ovc_array = np.asarray(ovc_np, np.float64)
ihydsp2_array = np.asarray(ihydsp2_np, np.float64)
ihydsplow_array = np.asarray(ihydsplow_np, np.float64)
igeoslope_array = np.asarray(igeoslope_np, np.float64)
# check that inputs are within range of fis
# if not, re-assign the value to just within range
ovc_array[ovc_array < 0] = 0
ovc_array[ovc_array > 45] = 45
ihydsp2_array[ihydsp2_array < 0] = 0.0001
ihydsp2_array[ihydsp2_array > 10000] = 10000
ihydsplow_array[ihydsplow_array < 0] = 0.0001
ihydsplow_array[ihydsplow_array > 10000] = 10000
igeoslope_array[igeoslope_array > 1] = 1
# delete temp arrays
items = [segid_np, ovc_np, ihydsp2_np, ihydsplow_np, igeoslope_np]
for item in items:
del item
# create antecedent (input) and consequent (output) objects to hold universe variables and membership functions
ovc = ctrl.Antecedent(np.arange(0, 45, 0.01), 'input1')
sp2 = ctrl.Antecedent(np.arange(0, 10000, 1), 'input2')
splow = ctrl.Antecedent(np.arange(0, 10000, 1), 'input3')
slope = ctrl.Antecedent(np.arange(0, 1, 0.0001), 'input4')
density = ctrl.Consequent(np.arange(0, 45, 0.01), 'result')
# build membership functions for each antecedent and consequent object
ovc['none'] = fuzz.trimf(ovc.universe, [0, 0, 0.1])
ovc['rare'] = fuzz.trapmf(ovc.universe, [0, 0.1, 0.5, 1.5])
ovc['occasional'] = fuzz.trapmf(ovc.universe, [0.5, 1.5, 4, 8])
ovc['frequent'] = fuzz.trapmf(ovc.universe, [4, 8, 12, 25])
ovc['pervasive'] = fuzz.trapmf(ovc.universe, [12, 25, 45, 45])
sp2['persists'] = fuzz.trapmf(sp2.universe, [0, 0, 1000, 1200])
sp2['breach'] = fuzz.trimf(sp2.universe, [1000, 1200, 1600])
sp2['oblowout'] = fuzz.trimf(sp2.universe, [1200, 1600, 2400])
sp2['blowout'] = fuzz.trapmf(sp2.universe, [1600, 2400, 10000, 10000])
splow['can'] = fuzz.trapmf(splow.universe, [0, 0, 150, 175])
splow['probably'] = fuzz.trapmf(splow.universe, [150, 175, 180, 190])
splow['cannot'] = fuzz.trapmf(splow.universe, [180, 190, 10000, 10000])
slope['flat'] = fuzz.trapmf(slope.universe, [0, 0, 0.0002, 0.005])
slope['can'] = fuzz.trapmf(slope.universe, [0.0002, 0.005, 0.12, 0.15])
slope['probably'] = fuzz.trapmf(slope.universe, [0.12, 0.15, 0.17, 0.23])
slope['cannot'] = fuzz.trapmf(slope.universe, [0.17, 0.23, 1, 1])
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(ovc['none'], density['none'])
rule2 = ctrl.Rule(splow['cannot'], density['none'])
rule3 = ctrl.Rule(slope['cannot'], density['none'])
rule4 = ctrl.Rule(
ovc['rare'] & sp2['persists'] & splow['can'] & ~slope['cannot'],
density['rare'])
rule5 = ctrl.Rule(
ovc['rare'] & sp2['persists'] & splow['probably'] & ~slope['cannot'],
density['rare'])
rule6 = ctrl.Rule(
ovc['rare'] & sp2['breach'] & splow['can'] & ~slope['cannot'],
density['rare'])
rule7 = ctrl.Rule(
ovc['rare'] & sp2['breach'] & splow['probably'] & ~slope['cannot'],
density['rare'])
rule8 = ctrl.Rule(
ovc['rare'] & sp2['oblowout'] & splow['can'] & ~slope['cannot'],
density['rare'])
rule9 = ctrl.Rule(
ovc['rare'] & sp2['oblowout'] & splow['probably'] & ~slope['cannot'],
density['rare'])
rule10 = ctrl.Rule(
ovc['rare'] & sp2['blowout'] & splow['can'] & ~slope['cannot'],
density['none'])
rule11 = ctrl.Rule(
ovc['rare'] & sp2['blowout'] & splow['probably'] & ~slope['cannot'],
density['none'])
rule12 = ctrl.Rule(
ovc['occasional'] & sp2['persists'] & splow['can'] & ~slope['cannot'],
density['occasional'])
rule13 = \
ctrl.Rule(ovc['occasional'] & sp2['persists'] & splow['probably'] & ~slope['cannot'], density['occasional'])
rule14 = ctrl.Rule(
ovc['occasional'] & sp2['breach'] & splow['can'] & ~slope['cannot'],
density['occasional'])
rule15 = ctrl.Rule(
ovc['occasional'] & sp2['breach'] & splow['probably']
& ~slope['cannot'], density['occasional'])
rule16 = ctrl.Rule(
ovc['occasional'] & sp2['oblowout'] & splow['can'] & ~slope['cannot'],
density['occasional'])
rule17 = \
ctrl.Rule(ovc['occasional'] & sp2['oblowout'] & splow['probably'] & ~slope['cannot'], density['occasional'])
rule18 = ctrl.Rule(
ovc['occasional'] & sp2['blowout'] & splow['can'] & ~slope['cannot'],
density['rare'])
rule19 = ctrl.Rule(
ovc['occasional'] & sp2['blowout'] & splow['probably']
& ~slope['cannot'], density['rare'])
rule20 = ctrl.Rule(
ovc['frequent'] & sp2['persists'] & splow['can'] & slope['flat'],
density['occasional'])
rule21 = ctrl.Rule(
ovc['frequent'] & sp2['persists'] & splow['can'] & slope['can'],
density['frequent'])
rule22 = ctrl.Rule(
ovc['frequent'] & sp2['persists'] & splow['can'] & slope['probably'],
density['occasional'])
rule23 = ctrl.Rule(
ovc['frequent'] & sp2['persists'] & splow['probably'] & slope['flat'],
density['occasional'])
rule24 = ctrl.Rule(
ovc['frequent'] & sp2['persists'] & splow['probably'] & slope['can'],
density['frequent'])
rule25 = ctrl.Rule(
ovc['frequent'] & sp2['persists'] & splow['probably']
& slope['probably'], density['occasional'])
rule26 = ctrl.Rule(
ovc['frequent'] & sp2['breach'] & splow['can'] & slope['flat'],
density['occasional'])
rule27 = ctrl.Rule(
ovc['frequent'] & sp2['breach'] & splow['can'] & slope['can'],
density['frequent'])
rule28 = ctrl.Rule(
ovc['frequent'] & sp2['breach'] & splow['can'] & slope['probably'],
density['occasional'])
rule29 = ctrl.Rule(
ovc['frequent'] & sp2['breach'] & splow['probably'] & slope['flat'],
density['occasional'])
rule30 = ctrl.Rule(
ovc['frequent'] & sp2['breach'] & splow['probably'] & slope['can'],
density['frequent'])
rule31 = ctrl.Rule(
ovc['frequent'] & sp2['breach'] & splow['probably']
& slope['probably'], density['occasional'])
rule32 = ctrl.Rule(
ovc['frequent'] & sp2['oblowout'] & splow['can'] & slope['flat'],
density['occasional'])
rule33 = ctrl.Rule(
ovc['frequent'] & sp2['oblowout'] & splow['can'] & slope['can'],
density['frequent'])
rule34 = ctrl.Rule(
ovc['frequent'] & sp2['oblowout'] & splow['can'] & slope['probably'],
density['occasional'])
rule35 = ctrl.Rule(
ovc['frequent'] & sp2['oblowout'] & splow['probably'] & slope['flat'],
density['rare'])
rule36 = ctrl.Rule(
ovc['frequent'] & sp2['oblowout'] & splow['probably'] & slope['can'],
density['occasional'])
rule37 = ctrl.Rule(
ovc['frequent'] & sp2['oblowout'] & splow['probably']
& slope['probably'], density['rare'])
rule38 = ctrl.Rule(
ovc['frequent'] & sp2['blowout'] & splow['can'] & slope['flat'],
density['rare'])
rule39 = ctrl.Rule(
ovc['frequent'] & sp2['blowout'] & splow['can'] & slope['can'],
density['rare'])
rule40 = ctrl.Rule(
ovc['frequent'] & sp2['blowout'] & splow['can'] & slope['probably'],
density['rare'])
rule41 = ctrl.Rule(
ovc['frequent'] & sp2['blowout'] & splow['probably'] & slope['flat'],
density['rare'])
rule42 = ctrl.Rule(
ovc['frequent'] & sp2['blowout'] & splow['probably'] & slope['can'],
density['rare'])
rule43 = ctrl.Rule(
ovc['frequent'] & sp2['blowout'] & splow['probably']
& slope['probably'], density['rare'])
rule44 = ctrl.Rule(
ovc['pervasive'] & sp2['persists'] & splow['can'] & slope['flat'],
density['frequent'])
rule45 = ctrl.Rule(
ovc['pervasive'] & sp2['persists'] & splow['can'] & slope['can'],
density['pervasive'])
rule46 = ctrl.Rule(
ovc['pervasive'] & sp2['persists'] & splow['can'] & slope['probably'],
density['frequent'])
rule47 = ctrl.Rule(
ovc['pervasive'] & sp2['persists'] & splow['probably'] & slope['flat'],
density['frequent'])
rule48 = ctrl.Rule(
ovc['pervasive'] & sp2['persists'] & splow['probably'] & slope['can'],
density['pervasive'])
rule49 = ctrl.Rule(
ovc['pervasive'] & sp2['persists'] & splow['probably']
& slope['probably'], density['frequent'])
rule50 = ctrl.Rule(
ovc['pervasive'] & sp2['breach'] & splow['can'] & slope['flat'],
density['frequent'])
rule51 = ctrl.Rule(
ovc['pervasive'] & sp2['breach'] & splow['can'] & slope['can'],
density['pervasive'])
rule52 = ctrl.Rule(
ovc['pervasive'] & sp2['breach'] & splow['can'] & slope['probably'],
density['frequent'])
rule53 = ctrl.Rule(
ovc['pervasive'] & sp2['breach'] & splow['probably'] & slope['flat'],
density['frequent'])
rule54 = ctrl.Rule(
ovc['pervasive'] & sp2['breach'] & splow['probably'] & slope['can'],
density['pervasive'])
rule55 = ctrl.Rule(
ovc['pervasive'] & sp2['breach'] & splow['probably']
& slope['probably'], density['frequent'])
rule56 = ctrl.Rule(
ovc['pervasive'] & sp2['oblowout'] & splow['can'] & slope['flat'],
density['frequent'])
rule57 = ctrl.Rule(
ovc['pervasive'] & sp2['oblowout'] & splow['can'] & slope['can'],
density['pervasive'])
rule58 = ctrl.Rule(
ovc['pervasive'] & sp2['oblowout'] & splow['can'] & slope['probably'],
density['frequent'])
rule59 = ctrl.Rule(
ovc['pervasive'] & sp2['oblowout'] & splow['probably'] & slope['flat'],
density['occasional'])
rule60 = ctrl.Rule(
ovc['pervasive'] & sp2['oblowout'] & splow['probably'] & slope['can'],
density['frequent'])
rule61 = \
ctrl.Rule(ovc['pervasive'] & sp2['oblowout'] & splow['probably'] & slope['probably'], density['occasional'])
rule62 = ctrl.Rule(
ovc['pervasive'] & sp2['blowout'] & splow['can'] & slope['flat'],
density['occasional'])
rule63 = ctrl.Rule(
ovc['pervasive'] & sp2['blowout'] & splow['can'] & slope['can'],
density['occasional'])
rule64 = ctrl.Rule(
ovc['pervasive'] & sp2['blowout'] & splow['can'] & slope['probably'],
density['rare'])
rule65 = ctrl.Rule(
ovc['pervasive'] & sp2['blowout'] & splow['probably'] & slope['flat'],
density['occasional'])
rule66 = ctrl.Rule(
ovc['pervasive'] & sp2['blowout'] & splow['probably'] & slope['can'],
density['occasional'])
rule67 = ctrl.Rule(
ovc['pervasive'] & sp2['blowout'] & splow['probably']
& slope['probably'], density['rare'])
comb_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, rule26, rule27, rule28,
rule29, rule30, rule31, rule32, rule33, rule34, rule35, rule36, rule37,
rule38, rule39, rule40, rule41, rule42, rule43, rule44, rule45, rule46,
rule47, rule48, rule49, rule50, rule51, rule52, rule53, rule54, rule55,
rule56, rule57, rule58, rule59, rule60, rule61, rule62, rule63, rule64,
rule65, rule66, rule67
])
comb_fis = ctrl.ControlSystemSimulation(comb_ctrl)
# run fuzzy inference system on inputs and defuzzify output
# TODO Test this using nas instead of zeros
out = np.zeros(len(ovc_array))
for i in range(len(out)):
comb_fis.input['input1'] = ovc_array[i]
comb_fis.input['input2'] = ihydsp2_array[i]
comb_fis.input['input3'] = ihydsplow_array[i]
comb_fis.input['input4'] = igeoslope_array[i]
comb_fis.compute()
out[i] = comb_fis.output['result']
# save fuzzy inference system output as table
columns = np.column_stack((segid_array, out))
out_table = os.path.dirname(in_network) + "/" + out_field + "_Table.txt"
# TODO See if possible to skip this step
np.savetxt(out_table,
columns,
delimiter=",",
header="ReachID, " + out_field,
comments="")
occ_table = scratch + "/" + out_field + "Tbl"
arcpy.CopyRows_management(out_table, occ_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(occ_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 bare excepts. What kind of error is this trying to catch?
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 combined capacity (occ_*) values in stream network
# correct for occ_* greater than ovc_* as vegetation is most limiting factor in model
# (i.e., combined fis value should not be greater than the vegetation capacity)
# set occ_* to 0 if the drainage area is greater than the user defined threshold
# this enforces a stream size threshold above which beaver dams won't persist and/or won't be built
# set occ_* 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, veg_field, 'iGeo_DA', 'iGeo_Slope']) 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
if row[0] > row[1]:
row[0] = row[1]
if row[2] >= float(max_da_thresh):
row[0] = 0.0
cursor.updateRow(row)
# delete temporary tables and arrays
arcpy.Delete_management(out_table)
arcpy.Delete_management(occ_table)
items = [columns, out, x, mfx_none, defuzz_none]
for item in items:
del item
# calculate dam count (mCC_**_CT) for each reach as number of dams * reach length (in km)
arcpy.AddField_management(in_network, mcc_field, 'SHORT')
with arcpy.da.UpdateCursor(in_network,
[mcc_field, out_field, 'iGeo_Len']) as cursor:
for row in cursor:
len_km = row[2] / 1000
raw_ct = row[1] * len_km
if 1 > raw_ct > 0:
row[0] = 1
else:
row[0] = round(raw_ct)
cursor.updateRow(row)
# calculate dam count historic departure as difference between potential count and existing count
if model_run == 'ex':
arcpy.AddField_management(in_network, 'mCC_HisDep', 'SHORT')
with arcpy.da.UpdateCursor(
in_network,
['mCC_HisDep', 'mCC_EX_CT', 'mCC_HPE_CT']) as cursor:
for row in cursor:
row[0] = row[2] - row[1]
cursor.updateRow(row)
# this is a refactored version of the code
import numpy as np
import skfuzzy as fuzz
from skfuzzy import control as ctrl # I am using this library to easily create membership functions
# Step 1: Create Antecedents/Consequents, plus variables to hold membership functions
age = ctrl.Antecedent(
np.arange(0, 10, 1), 'age'
) # -> this is our first antecedent, we repeat the logic, change the ranges
distance = ctrl.Antecedent(np.arange(0, 10, 1), 'distance')
energy_rating = ctrl.Antecedent(np.arange(0, 100, 1), 'energy_rating')
population = ctrl.Antecedent(np.arange(0, 10, 1), 'population')
# then the consequence, ranges really depend on your paramaters
price_increase = ctrl.Consequent(np.arange(0, 60, 1), 'price_increase')
# This method defines which membership functions are to be used dependant on the input variable
# universe is explicitly stating that these are global variables, specifically that they are "arrays"
def set_obj(obj, key1, value_1, key2, value_2, key3, value_3):
obj[key1] = fuzz.trimf(obj.universe, value_1)
if len(value_2) > 1:
obj[key2] = fuzz.trimf(obj.universe, value_2)
if obj.label == 'energy_rating':
obj[key3] = fuzz.trimf(obj.universe, value_3)
else:
obj[key3] = fuzz.trapmf(obj.universe, value_3)
# This defines the values to be used in each membership function as well as labeling them accordingly.
def Init_Rule(self):
universe0 = np.linspace(-3000, 3000, 5) # Delta Destination Distance
universe1 = np.linspace(-180, 180, 5) # Delta Destination Angular
universe2 = np.linspace(0, 25, 5) # Velocity
universe3 = np.array([-20, -15, 0, 15, 20]) # Angular Velocity
dD = ctrl.Antecedent(universe0, 'dD')
dT = ctrl.Antecedent(universe1, 'dT')
oV = ctrl.Consequent(universe2, 'oV')
oW = ctrl.Consequent(universe3, 'oW')
# names0 = ['nb', 'ns', 'ze', 'ps', 'pb']
dD.automf(names=['NHD', 'NLD', 'ZD', 'PLD', 'PHD'])
dT.automf(names=['NHA', 'NLA', 'ZA', 'PLA', 'PHA'])
oV.automf(names=['ZERO', 'SLOW', 'MEDIUM', 'FAST', 'HFAST'])
oW.automf(names=['HL', 'L', 'ST', 'R', 'HR'])
rule0 = ctrl.Rule(antecedent=(dD['NHD'] & dT['NHA']),
consequent=(oV['SLOW'], oW['HR']))
rule1 = ctrl.Rule(antecedent=(dD['NLD'] & dT['NHA']),
consequent=(oV['SLOW'], oW['HR']))
rule2 = ctrl.Rule(antecedent=(dD['ZD'] & dT['NHA']),
consequent=(oV['SLOW'], oW['HR']))
rule3 = ctrl.Rule(antecedent=(dD['PLD'] & dT['NHA']),
consequent=(oV['SLOW'], oW['R']))
rule4 = ctrl.Rule(antecedent=(dD['PHD'] & dT['NHA']),
consequent=(oV['SLOW'], oW['ST']))
rule5 = ctrl.Rule(antecedent=(dD['NHD'] & dT['NLA']),
consequent=(oV['SLOW'], oW['HR']))
rule6 = ctrl.Rule(antecedent=(dD['NLD'] & dT['NLA']),
consequent=(oV['SLOW'], oW['R']))
rule7 = ctrl.Rule(antecedent=(dD['ZD'] & dT['NLA']),
consequent=(oV['MEDIUM'], oW['R']))
rule8 = ctrl.Rule(antecedent=(dD['PLD'] & dT['NLA']),
consequent=(oV['SLOW'], oW['ST']))
rule9 = ctrl.Rule(antecedent=(dD['PHD'] & dT['NLA']),
consequent=(oV['SLOW'], oW['L']))
rule10 = ctrl.Rule(antecedent=(dD['NHD'] & dT['ZA']),
consequent=(oV['MEDIUM'], oW['HR']))
rule11 = ctrl.Rule(antecedent=(dD['NLD'] & dT['ZA']),
consequent=(oV['MEDIUM'], oW['R']))
rule12 = ctrl.Rule(antecedent=(dD['ZD'] & dT['ZA']),
consequent=(oV['FAST'], oW['ST']))
rule13 = ctrl.Rule(antecedent=(dD['PLD'] & dT['ZA']),
consequent=(oV['MEDIUM'], oW['L']))
rule14 = ctrl.Rule(antecedent=(dD['PHD'] & dT['ZA']),
consequent=(oV['MEDIUM'], oW['HL']))
rule15 = ctrl.Rule(antecedent=(dD['NHD'] & dT['PLA']),
consequent=(oV['SLOW'], oW['R']))
rule16 = ctrl.Rule(antecedent=(dD['NLD'] & dT['PLA']),
consequent=(oV['SLOW'], oW['ST']))
rule17 = ctrl.Rule(antecedent=(dD['ZD'] & dT['PLA']),
consequent=(oV['MEDIUM'], oW['L']))
rule18 = ctrl.Rule(antecedent=(dD['PLD'] & dT['PLA']),
consequent=(oV['SLOW'], oW['L']))
rule19 = ctrl.Rule(antecedent=(dD['PHD'] & dT['PLA']),
consequent=(oV['SLOW'], oW['HL']))
rule20 = ctrl.Rule(antecedent=(dD['NHD'] & dT['PHA']),
consequent=(oV['SLOW'], oW['ST']))
rule21 = ctrl.Rule(antecedent=(dD['NLD'] & dT['PHA']),
consequent=(oV['SLOW'], oW['L']))
rule22 = ctrl.Rule(antecedent=(dD['ZD'] & dT['PHA']),
consequent=(oV['SLOW'], oW['HL']))
rule23 = ctrl.Rule(antecedent=(dD['PLD'] & dT['PHA']),
consequent=(oV['SLOW'], oW['HL']))
rule24 = ctrl.Rule(antecedent=(dD['PHD'] & dT['PHA']),
consequent=(oV['SLOW'], oW['HL']))
self.my_rules = [
rule0, rule1, rule2, rule3, rule4, rule5, rule6, rule7, rule8,
rule9, rule10, rule11, rule12, rule13, rule14, rule15, rule16,
rule17, rule18, rule19, rule20, rule21, rule22, rule23, rule24
]
""" import numpy as np import skfuzzy as fuzz from skfuzzy import control as ctrl # New Antecedent/Consequent objects hold universe variables and membership \ # functions sleep_quality = ctrl.Antecedent(np.arange(0, 11, 1), 'sleep_quality') diet_quality = ctrl.Antecedent(np.arange(0, 11, 1), 'diet_quality') emotional_wellness = ctrl.Antecedent(np.arange(0, 11, 1), 'emotional_wellness') weather_quality = ctrl.Antecedent(np.arange(0, 11, 1), 'weather_quality') physical_wellness = ctrl.Antecedent(np.arange(0, 11, 1), 'physical_wellness') drug_dosage = ctrl.Consequent(np.arange(0, 5, 1), 'drug_dosage') # Auto-membership function population is possible with .automf(3, 5, or 7) sleep_quality.automf(3) diet_quality.automf(3) emotional_wellness.automf(3) weather_quality.automf(3) physical_wellness.automf(3) # Custom membership functions can be built interactively with a familiar, \ # Pythonic API drug_dosage['low'] = fuzz.trimf(drug_dosage.universe, [0, 0, 2]) drug_dosage['medium'] = fuzz.trimf(drug_dosage.universe, [0, 2, 4]) drug_dosage['high'] = fuzz.trimf(drug_dosage.universe, [2, 4, 4]) # You can see how these look with .view()
import numpy as np
import skfuzzy as fuzz
from skfuzzy import control as ctrl
# Antecedent for tire_pressure classification given from the output of the RNN
tire_pressure = ctrl.Antecedent(np.arange(0, 3, 1), 'tire_pressure')
# Consequent for the expected error in orientation based off the given tire_pressure classification
orientation_error = ctrl.Consequent(np.arange(-34, 34, 1), 'orientation_error')
predictionClass = 0
# Auto-membership function
tire_pressure.automf(3)
# Membership functions to compute the compensated orientation
orientation_error['center'] = fuzz.trimf(orientation_error.universe,
[-33, -33, 0])
orientation_error['left'] = fuzz.trimf(orientation_error.universe,
[-33, 0, 33])
orientation_error['right'] = fuzz.trimf(orientation_error.universe,
[0, 33, 33])
# Fuzzy Rules:
# IF the tires are full THEN keep center
# IF the right tires are flat THEN keep left
# IF the left tires are flat THEN keep right
rule1 = ctrl.Rule(tire_pressure['poor'], orientation_error['left'])
rule2 = ctrl.Rule(tire_pressure['average'], orientation_error['center'])
rule3 = ctrl.Rule(tire_pressure['good'], orientation_error['right'])
# note: Antecedents in skfuzzy can only have fuzzy values of 'poor', 'average', and 'good'
# poor: tires are full
# average: right tires are flat
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 = 100
var_in1_label = 'users'
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.2])
var_in1['average'] = fuzz.trapmf(var_in1.universe, [0, 0.2*in1_max, 0.8*in1_max, in1_max])
var_in1['high'] = fuzz.trimf(var_in1.universe, [0.8*in1_max, in1_max, 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['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
def handle_segment_size_request(self, msg):
time_stop = datetime.datetime.now(
) # tempo guardado para calcular a vazão
self.add_time(time_stop.timestamp())
moving_avarage_factor = 5 # Usado para fazer média das últimas 5 qualidades para não variar bruscamente
buffer_now = self.whiteboard.get_playback_buffer_size()
throughput = 0
max_throughput = 2
quality_moving_avg = 0
medium_quality = 8 # Valor inicial já que a qualidade média é calculada em tempo real usando os últimos 20 items
medium_connection_throughput = -1
if len(self.time_of_request) > 2:
time_to_request = self.time_of_request[-1] - self.time_of_request[
-2]
throughput = self.bit_len[-1] / (time_to_request)
self.add_throughput(throughput)
max_throughput = max(self.throughput_arr)
medium_connection_throughput = avg(self.throughput_arr[-20:])
if len(buffer_now) > 0:
buffer_now = buffer_now[-1][1]
else:
buffer_now = 0
qualityArr = self.whiteboard.get_playback_qi()
if len(qualityArr) > 0:
medium_quality = qualityArr
qualityArr = qualityArr[-moving_avarage_factor:]
qualityArr = [item[1] for item in qualityArr]
quality_moving_avg = avg(qualityArr)
medium_quality = medium_quality[-20:] # Valor médio da qualidade
medium_quality = [item[1] for item in medium_quality]
medium_quality = avg_the_last_is_the_most_significant(
medium_quality)
else:
quality_moving_avg = 0
max_buffer_size = self.config_parameters["max_buffer_size"]
if len(self.time_of_request) < 4:
medium_buffer_size = 0.5 * max_buffer_size
else:
medium_buffer_size = 0.6 * max_buffer_size - (
0.4 * max_buffer_size *
(self.time_of_request[-1] - self.time_of_request[0]) /
self.duration)
if medium_buffer_size < 0.2 * max_buffer_size:
medium_buffer_size = 0.2 * max_buffer_size
print('buffer -----------', medium_buffer_size)
max_throughput_step = 1
if max_throughput > 100:
max_throughput_step = max_throughput / 40
connection_throughput = ctrl.Antecedent(
np.arange(0, max_throughput, max_throughput_step),
'connection_throughput')
buffer = ctrl.Antecedent(np.arange(0, max_buffer_size + 1, 1),
'buffer')
quality = ctrl.Consequent(np.arange(0, self.qualities_len, 1),
'quality')
# connection_throughput.automf(3)
if medium_connection_throughput == -1:
medium_connection_throughput = max_throughput / 2
connection_throughput['poor'] = fuzz.trimf(
connection_throughput.universe, [0, 0, round(max_throughput)])
connection_throughput['average'] = fuzz.trimf(
connection_throughput.universe,
[0, round(medium_connection_throughput),
round(max_throughput)])
connection_throughput['good'] = fuzz.trimf(
connection_throughput.universe, [
round(medium_connection_throughput),
round(max_throughput),
round(max_throughput)
])
buffer['low'] = fuzz.trimf(buffer.universe,
[0, 0, round(medium_buffer_size)])
buffer['medium'] = fuzz.trimf(
buffer.universe, [0, round(medium_buffer_size), max_buffer_size])
buffer['high'] = fuzz.trimf(
buffer.universe,
[round(medium_buffer_size), max_buffer_size, max_buffer_size])
quality['low'] = fuzz.trimf(quality.universe,
[0, 0, round(medium_quality)])
quality['medium'] = fuzz.trimf(
quality.universe,
[0, round(medium_quality), self.qualities_len - 1])
quality['high'] = fuzz.trimf(quality.universe, [
round(medium_quality), self.qualities_len - 1,
self.qualities_len - 1
])
# quality.view()
# wait = input("Press Enter to continue.")
rule1 = ctrl.Rule(connection_throughput['poor'] | buffer['low'],
quality['low'])
rule2 = ctrl.Rule(connection_throughput['average'], quality['medium'])
# rule2 = ctrl.Rule(connection_throughput['average'] & buffer['medium'], quality['medium'])
rule3 = ctrl.Rule(connection_throughput['good'] & buffer['low'],
quality['medium'])
# rule4 = ctrl.Rule(connection_throughput['good'] & buffer['medium'], quality['high'])
rule4 = ctrl.Rule(connection_throughput['good'] & buffer['high'],
quality['high'])
quality_ctrl = ctrl.ControlSystem([rule1, rule2, rule3, rule4])
new_quality = ctrl.ControlSystemSimulation(quality_ctrl)
new_quality.input['buffer'] = buffer_now
new_quality.input['connection_throughput'] = throughput
new_quality.compute()
quality_moving_avg = avg(
[quality_moving_avg, new_quality.output['quality']])
print('new quality---->', quality_moving_avg)
# msg.add_quality_id(self.qi[int(quality_moving_avg)])
msg.add_quality_id(self.qi[round(quality_moving_avg)])
self.send_down(msg)
import numpy as np import skfuzzy as fuzz from skfuzzy import control as ctrl # import matplotlib.pyplot as plt # input time_dist = ctrl.Antecedent(np.arange(0, 2.05, 0.05), 'time_dist') y_dist = ctrl.Antecedent(np.arange(-600, 601, 1), 'y_dist') y_player = ctrl.Antecedent(np.arange(0, 601, 1), 'y_player') # output move = ctrl.Consequent(np.arange(-800, 810, 10), 'move') time_dist['very small'] = fuzz.trimf(time_dist.universe, [0, 0, 0.1]) time_dist['small'] = fuzz.trimf(time_dist.universe, [0, 0.1, 0.3]) time_dist['medium'] = fuzz.trimf(time_dist.universe, [0.1, 0.3, 1]) time_dist['big'] = fuzz.trimf(time_dist.universe, [0.3, 2, 2]) y_dist['negative big'] = fuzz.trimf(y_dist.universe, [-600, -600, -80]) y_dist['negative small'] = fuzz.trimf(y_dist.universe, [-600, -80, 0]) y_dist['negative very small'] = fuzz.trimf(y_dist.universe, [-80, -1, 1]) y_dist['positive very small'] = fuzz.trimf(y_dist.universe, [-1, 1, 80]) y_dist['positive small'] = fuzz.trimf(y_dist.universe, [0, 80, 600]) y_dist['positive big'] = fuzz.trimf(y_dist.universe, [80, 600, 600]) y_player['top'] = fuzz.trimf(y_player.universe, [0, 0, 90]) y_player['middle'] = fuzz.trapmf(y_player.universe, [0, 90, 510, 600]) y_player['bottom'] = fuzz.trimf(y_player.universe, [510, 600, 600]) move['fast up'] = fuzz.trimf(move.universe, [-800, -800, -450]) move['slow up'] = fuzz.trimf(move.universe, [-800, -450, 0])
import numpy as np import skfuzzy as fuzz from skfuzzy import control as ctrl potencia = ctrl.Antecedent(np.arange(0, 101, 1), 'potência') vazao = ctrl.Antecedent(np.arange(0, 101, 1), 'vazão') temperatura = ctrl.Consequent(np.arange(15, 46, 1), 'temperatura') # Funções de Pertinência para a potência potencia['baixa'] = fuzz.trapmf(potencia.universe, [0, 0, 20, 50]) potencia['média'] = fuzz.trimf(potencia.universe, [20, 50, 80]) potencia['alta'] = fuzz.trapmf(potencia.universe, [50, 80, 100, 100]) # Funções de Pertinência para a vazão vazao['baixa'] = fuzz.trapmf(vazao.universe, [0, 0, 20, 50]) vazao['média'] = fuzz.trimf(vazao.universe, [20, 50, 80]) vazao['alta'] = fuzz.trapmf(vazao.universe, [50, 80, 100, 100]) # Funções de Pertinência para a temperatura temperatura['baixa'] = fuzz.trapmf(temperatura.universe, [15, 15, 20, 30]) temperatura['agradável'] = fuzz.trimf(temperatura.universe, [20, 30, 40]) temperatura['alta'] = fuzz.trapmf(temperatura.universe, [30, 40, 45, 45]) potencia.view() vazao.view() temperatura.view() # Regras de Inferência rule1 = ctrl.Rule(potencia['baixa'] & vazao['baixa'], temperatura['agradável'])
loaded_model = pickle.load(open(filename, 'rb'))
# result = loaded_model.score(X_test, Y_test)
# print(result)
#output of ML model
out_ml_model = loaded_model.predict_proba([[
avg_running_time, avg_number_of_jumps, avg_Crouch_time_plus_walking_time
]])[0][1]
out_ml_model = out_ml_model * 100
print("is_aggresive : {}%".format(out_ml_model))
# Antecedent
is_aggresive = ctrl.Antecedent(np.arange(0, 101, 1), 'is_aggresive')
# Consequent
gun_damage_pc = ctrl.Consequent(np.arange(0, 101, 1), 'gun_damage_pc')
speed_npc = ctrl.Consequent(np.arange(0, 101, 1), 'speed_npc')
gun_accuracy_npc = ctrl.Consequent(np.arange(0, 101, 1), 'gun_accuracy_npc')
gun_damage_npc = ctrl.Consequent(np.arange(0, 101, 1), 'gun_damage_npc')
health_dec_factor = ctrl.Consequent(np.arange(0, 101, 1), 'health_dec_factor')
ammo = ctrl.Consequent(np.arange(0, 101, 1), 'ammo')
tot_enemy = ctrl.Consequent(np.arange(0, 101, 1), 'tot_enemy')
tot_enemy_1_location = ctrl.Consequent(np.arange(0, 101, 1),
'tot_enemy_1_location')
# membershio function of Antecedent
is_aggresive['passive'] = fuzz.trimf(is_aggresive.universe, [0, 0, 100])
is_aggresive['aggresive'] = fuzz.trimf(is_aggresive.universe, [0, 100, 100])
# membership functions of Consequent
if gun_damage_pc_funtype == 0:
def main(in_network, scratch):
net_gpd = gpd.read_file(in_network, driver="ESRI Shapefile")
net_gpd.loc[net_gpd['iVeg_40'] < 0, 'iVeg_40'] = 0
net_gpd.loc[net_gpd['iVeg_10'] < 0, 'iVeg_10'] = 0
net_gpd.loc[net_gpd['iVeg_40'] > 5, 'iVeg_40'] = 5
net_gpd.loc[net_gpd['iVeg_10'] > 5, 'iVeg_10'] = 5
riparian_array = net_gpd['iVeg_40'].values
streamside_array = net_gpd['iVeg_10'].values
# set up input and output ranges
riparian = ctrl.Antecedent(np.arange(0, 5, 0.001), 'input1')
streamside = ctrl.Antecedent(np.arange(0, 5, 0.001), 'input2')
density = ctrl.Consequent(np.arange(0, 45, 0.5), 'result')
riparian['unsuitablea'] = fuzz.trapmf(streamside.universe, [0, 0, 1, 1.5])
riparian['barelya'] = fuzz.trapmf(streamside.universe, [1, 1.5, 2, 2.25])
riparian['moderatelya'] = fuzz.trapmf(streamside.universe, [2, 2.25, 3.5, 4])
riparian['suitablea'] = fuzz.trapmf(streamside.universe, [3.5, 4, 4.75, 5])
riparian['preferreda'] = fuzz.trimf(riparian.universe, [4.5, 5, 5])
streamside['unsuitable'] = fuzz.trapmf(streamside.universe, [0, 0, 1, 1.5])
streamside['barely'] = fuzz.trapmf(streamside.universe, [1, 1.5, 2, 2.25])
streamside['moderately'] = fuzz.trapmf(streamside.universe, [2, 2.25, 3.5, 4])
streamside['suitable'] = fuzz.trapmf(streamside.universe, [3.5, 4, 4.75, 5])
streamside['preferred'] = fuzz.trimf(riparian.universe, [4.5, 5, 5])
density['none'] = fuzz.trimf(density.universe, [0, 0, 0])
density['rare'] = fuzz.trapmf(density.universe, [0, 0, 1.0, 1.5])
density['occasional'] = fuzz.trapmf(density.universe, [1, 1.5, 4, 8])
density['frequent'] = fuzz.trapmf(density.universe, [4, 8, 12, 25])
density['pervasive'] = fuzz.trapmf(density.universe, [12, 25, 45, 45])
# rules
rule1 = ctrl.Rule(riparian['unsuitablea'] & streamside['unsuitable'], density['none'])
rule2 = ctrl.Rule(riparian['barelya'] & streamside['unsuitable'], density['none'])
rule3 = ctrl.Rule(riparian['moderatelya'] & streamside['unsuitable'], density['rare'])
rule4 = ctrl.Rule(riparian['suitablea'] & streamside['unsuitable'], density['occasional'])
rule5 = ctrl.Rule(riparian['preferreda'] & streamside['unsuitable'], density['frequent'])
rule6 = ctrl.Rule(riparian['unsuitablea'] & streamside['barely'], density['rare'])
rule7 = ctrl.Rule(riparian['barelya'] & streamside['barely'], density['rare'])
rule8 = ctrl.Rule(riparian['moderatelya'] & streamside['barely'], density['occasional'])
rule9 = ctrl.Rule(riparian['suitablea'] & streamside['barely'], density['frequent'])
rule10 = ctrl.Rule(riparian['preferreda'] & streamside['barely'], density['frequent'])
rule11 = ctrl.Rule(riparian['unsuitablea'] & streamside['moderately'], density['occasional']) #
rule12 = ctrl.Rule(riparian['barelya'] & streamside['moderately'], density['occasional'])
rule13 = ctrl.Rule(riparian['moderatelya'] & streamside['moderately'], density['occasional'])
rule14 = ctrl.Rule(riparian['suitablea'] & streamside['moderately'], density['frequent'])
rule15 = ctrl.Rule(riparian['preferreda'] & streamside['moderately'], density['frequent'])
rule16 = ctrl.Rule(riparian['unsuitablea'] & streamside['suitable'], density['occasional'])
rule17 = ctrl.Rule(riparian['barelya'] & streamside['suitable'], density['frequent'])
rule18 = ctrl.Rule(riparian['moderatelya'] & streamside['suitable'], density['frequent'])
rule19 = ctrl.Rule(riparian['suitablea'] & streamside['suitable'], density['frequent'])
rule20 = ctrl.Rule(riparian['preferreda'] & streamside['suitable'], density['pervasive'])
rule21 = ctrl.Rule(riparian['unsuitablea'] & streamside['preferred'], density['frequent'])
rule22 = ctrl.Rule(riparian['barelya'] & streamside['preferred'], density['frequent'])
rule23 = ctrl.Rule(riparian['moderatelya'] & streamside['preferred'], density['frequent'])
rule24 = ctrl.Rule(riparian['suitablea'] & streamside['preferred'], density['pervasive'])
rule25 = ctrl.Rule(riparian['preferreda'] & 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)
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']
net_gpd['oVC_EX'] = out
net_gpd.to_file(in_network, driver="ESRI Shapefile")
return in_network
import numpy as np import skfuzzy as fuzz from skfuzzy import control as ctrl #Antecedents/Consequents D = ctrl.Antecedent(np.arange(0,10.5,0.5), "distance") A = ctrl.Antecedent(np.arange(0, 91, 1), "angle") S = ctrl.Consequent(np.arange(0, 5.2, 0.2), "speed", defuzzify_method="mom") ST = ctrl.Consequent(np.arange(0, 91, 1), "steering", defuzzify_method="lom") #Memberships D["N"] = fuzz.trimf(D.universe,[0,0,5]) D["F"] = fuzz.trimf(D.universe, [2.5,5,7.5]) D["VF"] = fuzz.trimf(D.universe, [5,10,10]) A["S"] = fuzz.trimf(A.universe,[0, 0, 20]) A["M"] = fuzz.trimf(A.universe, [15, 40, 60]) A["L"] = fuzz.trimf(A.universe, [55, 90, 90]) S["SS"] = fuzz.trimf(S.universe, [0, 0, 1.6]) S["MS"] = fuzz.trimf(S.universe, [1.2,2,2.8]) S["FS"] = fuzz.trimf(S.universe, [2.4, 3.2, 4]) S["MXS"] = fuzz.trimf(S.universe, [3.6, 5, 5]) ST["MST"] = fuzz.trimf(A.universe,[0, 0, 35]) ST["SST"] = fuzz.trimf(A.universe, [25, 45, 60]) ST["VST"] = fuzz.trimf(A.universe, [55, 90, 90]) #Rules
def fuzzy_rules(sentence_feature_object):
# print(sentence_feature_object)
universe_features = np.arange(0,1,0.001)
universe_result = np.arange(0,1,0.01)
title_word = ctrl.Antecedent(universe_features, 'title_word')
sentence_length = ctrl.Antecedent(universe_features, 'sentence_length')
sentence_location = ctrl.Antecedent(universe_features, 'sentence_location')
numerical_data = ctrl.Antecedent(universe_features, 'numerical_data')
# thematic_keyword = ctrl.Antecedent(universe_features, 'thematic_keyword')
# proper_noun = ctrl.Antecedent(universe_features, 'proper_noun')
# sentence_similarity = ctrl.Antecedent(universe_features, 'sentence_similarity')
# term_weight = ctrl.Antecedent(universe_features, 'term_weight')
result = ctrl.Consequent(universe_result, 'result')
# Auto-membership function population is possible with .automf(3, 5, or 7)
title_word.automf(3)
sentence_length.automf(3)
sentence_location.automf(3)
numerical_data.automf(3)
# thematic_keyword.automf(3)
# proper_noun.automf(3)
# sentence_similarity.automf(3)
# term_weight.automf(3)
# Custom membership functions can be built interactively with a familiar,
# Pythonic API
result['low'] = fuzzy.trimf(result.universe, [0.000,0.30,0.500])
result['medium'] = fuzzy.trimf(result.universe, [0.300,0.500,0.700])
result['high'] = fuzzy.trimf(result.universe, [0.500,1.0,1.0])
# 'poor'; 'average', or 'good'
rule1 = ctrl.Rule(title_word["poor"] & sentence_length["poor"] & sentence_location["poor"] & numerical_data["poor"], result['low'])
rule2 = ctrl.Rule(title_word["poor"] & sentence_length["poor"] & sentence_location["poor"] & numerical_data["average"], result['low'])
rule3 = ctrl.Rule(title_word["poor"] & sentence_length["poor"] & sentence_location["poor"] & numerical_data["good"], result['low'])
rule4 = ctrl.Rule(title_word["poor"] & sentence_length["poor"] & sentence_location["average"] & numerical_data["poor"], result['low'])
rule5 = ctrl.Rule(title_word["poor"] & sentence_length["poor"] & sentence_location["average"] & numerical_data["average"], result['low'])
rule6 = ctrl.Rule(title_word["poor"] & sentence_length["poor"] & sentence_location["average"] & numerical_data["good"], result['low'])
rule7 = ctrl.Rule(title_word["poor"] & sentence_length["poor"] & sentence_location["good"] & numerical_data["poor"], result['low'])
rule8 = ctrl.Rule(title_word["poor"] & sentence_length["poor"] & sentence_location["good"] & numerical_data["average"], result['low'])
rule9 = ctrl.Rule(title_word["poor"] & sentence_length["poor"] & sentence_location["good"] & numerical_data["good"], result['low'])
rule10 = ctrl.Rule(title_word["poor"] & sentence_length["average"] & sentence_location["poor"] & numerical_data["poor"], result['low'])
rule11 = ctrl.Rule(title_word["poor"] & sentence_length["average"] & sentence_location["poor"] & numerical_data["average"], result['low'])
rule12 = ctrl.Rule(title_word["poor"] & sentence_length["average"] & sentence_location["poor"] & numerical_data["good"], result['low'])
rule13 = ctrl.Rule(title_word["poor"] & sentence_length["average"] & sentence_location["average"] & numerical_data["poor"], result['low'])
rule14 = ctrl.Rule(title_word["poor"] & sentence_length["average"] & sentence_location["average"] & numerical_data["average"], result['medium'])
rule15 = ctrl.Rule(title_word["poor"] & sentence_length["average"] & sentence_location["average"] & numerical_data["good"], result['medium'])
rule16 = ctrl.Rule(title_word["poor"] & sentence_length["average"] & sentence_location["good"] & numerical_data["poor"], result['low'])
rule17 = ctrl.Rule(title_word["poor"] & sentence_length["average"] & sentence_location["good"] & numerical_data["average"], result['medium'])
rule18 = ctrl.Rule(title_word["poor"] & sentence_length["average"] & sentence_location["good"] & numerical_data["good"], result['high'])
rule19 = ctrl.Rule(title_word["poor"] & sentence_length["good"] & sentence_location["poor"] & numerical_data["poor"], result['low'])
rule20 = ctrl.Rule(title_word["poor"] & sentence_length["good"] & sentence_location["poor"] & numerical_data["average"], result['low'])
rule21 = ctrl.Rule(title_word["poor"] & sentence_length["good"] & sentence_location["poor"] & numerical_data["good"], result['low'])
rule22 = ctrl.Rule(title_word["poor"] & sentence_length["good"] & sentence_location["average"] & numerical_data["poor"], result['low'])
rule23 = ctrl.Rule(title_word["poor"] & sentence_length["good"] & sentence_location["average"] & numerical_data["average"], result['medium'])
rule24 = ctrl.Rule(title_word["poor"] & sentence_length["good"] & sentence_location["average"] & numerical_data["good"], result['high'])
rule25 = ctrl.Rule(title_word["poor"] & sentence_length["good"] & sentence_location["good"] & numerical_data["poor"], result['low'])
rule26 = ctrl.Rule(title_word["poor"] & sentence_length["good"] & sentence_location["good"] & numerical_data["average"], result['high'])
rule27 = ctrl.Rule(title_word["poor"] & sentence_length["good"] & sentence_location["good"] & numerical_data["good"], result['high'])
rule28 = ctrl.Rule(title_word["average"] & sentence_length["poor"] & sentence_location["poor"] & numerical_data["poor"], result['low'])
rule29 = ctrl.Rule(title_word["average"] & sentence_length["poor"] & sentence_location["poor"] & numerical_data["average"], result['low'])
rule30 = ctrl.Rule(title_word["average"] & sentence_length["poor"] & sentence_location["poor"] & numerical_data["good"], result['low'])
rule31 = ctrl.Rule(title_word["average"] & sentence_length["poor"] & sentence_location["average"] & numerical_data["poor"], result['low'])
rule32 = ctrl.Rule(title_word["average"] & sentence_length["poor"] & sentence_location["average"] & numerical_data["average"], result['medium'])
rule33 = ctrl.Rule(title_word["average"] & sentence_length["poor"] & sentence_location["average"] & numerical_data["good"], result['medium'])
rule34 = ctrl.Rule(title_word["average"] & sentence_length["poor"] & sentence_location["good"] & numerical_data["poor"], result['low'])
rule35 = ctrl.Rule(title_word["average"] & sentence_length["poor"] & sentence_location["good"] & numerical_data["average"], result['medium'])
rule36 = ctrl.Rule(title_word["average"] & sentence_length["poor"] & sentence_location["good"] & numerical_data["good"], result['high'])
rule37 = ctrl.Rule(title_word["average"] & sentence_length["average"] & sentence_location["poor"] & numerical_data["poor"], result['low'])
rule38 = ctrl.Rule(title_word["average"] & sentence_length["average"] & sentence_location["poor"] & numerical_data["average"], result['medium'])
rule39 = ctrl.Rule(title_word["average"] & sentence_length["average"] & sentence_location["poor"] & numerical_data["good"], result['medium'])
rule40 = ctrl.Rule(title_word["average"] & sentence_length["average"] & sentence_location["average"] & numerical_data["poor"], result['medium'])
rule41 = ctrl.Rule(title_word["average"] & sentence_length["average"] & sentence_location["average"] & numerical_data["average"], result['medium'])
rule42 = ctrl.Rule(title_word["average"] & sentence_length["average"] & sentence_location["average"] & numerical_data["good"], result['medium'])
rule43 = ctrl.Rule(title_word["average"] & sentence_length["average"] & sentence_location["good"] & numerical_data["poor"], result['medium'])
rule44 = ctrl.Rule(title_word["average"] & sentence_length["average"] & sentence_location["good"] & numerical_data["average"], result['medium'])
rule45 = ctrl.Rule(title_word["average"] & sentence_length["average"] & sentence_location["good"] & numerical_data["good"], result['medium'])
rule46 = ctrl.Rule(title_word["average"] & sentence_length["good"] & sentence_location["poor"] & numerical_data["poor"], result['low'])
rule47 = ctrl.Rule(title_word["average"] & sentence_length["good"] & sentence_location["poor"] & numerical_data["average"], result['medium'])
rule48 = ctrl.Rule(title_word["average"] & sentence_length["good"] & sentence_location["poor"] & numerical_data["good"], result['high'])
rule49 = ctrl.Rule(title_word["average"] & sentence_length["good"] & sentence_location["average"] & numerical_data["poor"], result['medium'])
rule50 = ctrl.Rule(title_word["average"] & sentence_length["good"] & sentence_location["average"] & numerical_data["average"], result['medium'])
rule51 = ctrl.Rule(title_word["average"] & sentence_length["good"] & sentence_location["average"] & numerical_data["good"], result['medium'])
rule52 = ctrl.Rule(title_word["average"] & sentence_length["good"] & sentence_location["good"] & numerical_data["poor"], result['high'])
rule53 = ctrl.Rule(title_word["average"] & sentence_length["good"] & sentence_location["good"] & numerical_data["average"], result['medium'])
rule54 = ctrl.Rule(title_word["average"] & sentence_length["good"] & sentence_location["good"] & numerical_data["good"], result['high'])
rule55 = ctrl.Rule(title_word["good"] & sentence_length["poor"] & sentence_location["poor"] & numerical_data["poor"], result['low'])
rule56 = ctrl.Rule(title_word["good"] & sentence_length["poor"] & sentence_location["poor"] & numerical_data["average"], result['low'])
rule57 = ctrl.Rule(title_word["good"] & sentence_length["poor"] & sentence_location["poor"] & numerical_data["good"], result['low'])
rule58 = ctrl.Rule(title_word["good"] & sentence_length["poor"] & sentence_location["average"] & numerical_data["poor"], result['low'])
rule59 = ctrl.Rule(title_word["good"] & sentence_length["poor"] & sentence_location["average"] & numerical_data["average"], result['medium'])
rule60 = ctrl.Rule(title_word["good"] & sentence_length["poor"] & sentence_location["average"] & numerical_data["good"], result['high'])
rule61 = ctrl.Rule(title_word["good"] & sentence_length["poor"] & sentence_location["good"] & numerical_data["poor"], result['low'])
rule62 = ctrl.Rule(title_word["good"] & sentence_length["poor"] & sentence_location["good"] & numerical_data["average"], result['high'])
rule63 = ctrl.Rule(title_word["good"] & sentence_length["poor"] & sentence_location["good"] & numerical_data["good"], result['high'])
rule64 = ctrl.Rule(title_word["good"] & sentence_length["average"] & sentence_location["poor"] & numerical_data["poor"], result['low'])
rule65 = ctrl.Rule(title_word["good"] & sentence_length["average"] & sentence_location["poor"] & numerical_data["average"], result['medium'])
rule66 = ctrl.Rule(title_word["good"] & sentence_length["average"] & sentence_location["poor"] & numerical_data["good"], result['high'])
rule67 = ctrl.Rule(title_word["good"] & sentence_length["average"] & sentence_location["average"] & numerical_data["poor"], result['medium'])
rule68 = ctrl.Rule(title_word["good"] & sentence_length["average"] & sentence_location["average"] & numerical_data["average"], result['medium'])
rule69 = ctrl.Rule(title_word["good"] & sentence_length["average"] & sentence_location["average"] & numerical_data["good"], result['medium'])
rule70 = ctrl.Rule(title_word["good"] & sentence_length["average"] & sentence_location["good"] & numerical_data["poor"], result['high'])
rule71 = ctrl.Rule(title_word["good"] & sentence_length["average"] & sentence_location["good"] & numerical_data["average"], result['medium'])
rule72 = ctrl.Rule(title_word["good"] & sentence_length["average"] & sentence_location["good"] & numerical_data["good"], result['high'])
rule73 = ctrl.Rule(title_word["good"] & sentence_length["good"] & sentence_location["poor"] & numerical_data["poor"], result['low'])
rule74 = ctrl.Rule(title_word["good"] & sentence_length["good"] & sentence_location["poor"] & numerical_data["average"], result['high'])
rule75 = ctrl.Rule(title_word["good"] & sentence_length["good"] & sentence_location["poor"] & numerical_data["good"], result['high'])
rule76 = ctrl.Rule(title_word["good"] & sentence_length["good"] & sentence_location["average"] & numerical_data["poor"], result['high'])
rule77 = ctrl.Rule(title_word["good"] & sentence_length["good"] & sentence_location["average"] & numerical_data["average"], result['medium'])
rule78 = ctrl.Rule(title_word["good"] & sentence_length["good"] & sentence_location["average"] & numerical_data["good"], result['high'])
rule79 = ctrl.Rule(title_word["good"] & sentence_length["good"] & sentence_location["good"] & numerical_data["poor"], result['high'])
rule80 = ctrl.Rule(title_word["good"] & sentence_length["good"] & sentence_location["good"] & numerical_data["average"], result['high'])
rule81 = ctrl.Rule(title_word["good"] & sentence_length["good"] & sentence_location["good"] & numerical_data["good"], result['high'])
tipping_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, rule26, rule27, rule28, rule29, rule30, rule31, rule32, rule33, rule34, rule35, rule36, rule37, rule38, rule39, rule40, rule41, rule42, rule43, rule44, rule45, rule46, rule47, rule48, rule49, rule50, rule51, rule52, rule53, rule54, rule55, rule56, rule57, rule58, rule59, rule60, rule61, rule62, rule63, rule64, rule65, rule66, rule67, rule68, rule69, rule70, rule71, rule72, rule73, rule74, rule75, rule76, rule77, rule78, rule79, rule80, rule81])
# tipping_ctrl = acr.customRule()
#tipping control simmulation
tipping = ctrl.ControlSystemSimulation(tipping_ctrl)
# Pass inputs to the ControlSystem using Antecedent labels with Pythonic API
# Note: if you like passing many inputs all at once, use .inputs(dict_of_data)
tipping.input['title_word'] = sentence_feature_object['title_word']
tipping.input['sentence_length'] = sentence_feature_object['sentence_length']
tipping.input['sentence_location'] = sentence_feature_object['sentence_location']
tipping.input['numerical_data'] = sentence_feature_object['numerical_data']
# tipping.input['thematic_keyword'] = sentence_feature_object['thematic_keyword']
# tipping.input['proper_noun'] = sentence_feature_object['proper_noun']
# tipping.input['sentence_similarity'] = sentence_feature_object['sentence_similarity']
# tipping.input['term_weight'] = sentence_feature_object['term_weight']
# tipping.inputs(sentence_feature_object)
# Crunch the numbers
tipping.compute()
return tipping.output['result']
import numpy as np
import skfuzzy as fuzz
from skfuzzy import control as ctrl
import time
import datetime
import matplotlib.pyplot as plt
##----------------Fuzzy Setting-----------------------------#
# New Antecedent/Consequent objects hold universe variables and membership
# functions
sound =ctrl.Antecedent(np.arange(0, 11, 1), 'sound')
air =ctrl.Antecedent(np.arange(0, 11, 1), 'air')
#light =ctrl.Antecedent(np.arange(0, 11, 1), 'temp')
switch_power = ctrl.Consequent(np.arange(0, 11, 1), 'switch_power')
sound.automf(3)
air.automf(3)
#light.automf(3)
#switch_power.automf(3)
switch_power['low'] = fuzz.trimf(switch_power.universe, [0, 0, 5])
switch_power['medium'] = fuzz.trimf(switch_power.universe, [0, 5, 10])
switch_power['high'] = fuzz.trimf(switch_power.universe, [5, 10, 10])
rule1 = ctrl.Rule(air['good'], switch_power['high'])
rule2 = ctrl.Rule(air['average'] & sound['average'], switch_power['low'])
rule3 = ctrl.Rule(air['average'] & sound['poor'] ,switch_power['high'])
rule4 = ctrl.Rule(air['poor'] | sound['good'], switch_power['low'])
tipping_ctrl = ctrl.ControlSystem([rule1,rule2,rule3,rule4])
tipping = ctrl.ControlSystemSimulation(tipping_ctrl)
#sound['average'].view()
#air['average'].view()
def fuzzy_logic_algo(sb, sk, crf):
# New Antecedent/Consequent objects hold universe variables and membership
# functions
skill = ctrl.Antecedent(np.arange(0, 51, 1), 'skill')
academic = ctrl.Antecedent(np.arange(0, 101, 1), 'academic')
sucsratio = ctrl.Consequent(np.arange(0, 101, 1), 'success')
# Custom membership functions can be built interactively with a familiar,
# Pythonic API
# Generate trapezoidal fuzzy membership functions
skill['poor'] = fuzz.trapmf(skill.universe,
[0, 0, 15, 17]) # skill weak[0-17]
skill['average'] = fuzz.trapmf(skill.universe,
[17, 20, 30, 37]) # skill medium[17-37]
skill['good'] = fuzz.trapmf(skill.universe,
[35, 37, 50, 50]) # skill good[35-50]
# Generate trapezoidal fuzzy membership functions
academic['poor'] = fuzz.trapmf(academic.universe,
[0, 0, 40, 45]) # academic score weak[0-45]
academic['average'] = fuzz.trapmf(
academic.universe, [40, 45, 65, 70]) # academic score medium[40-70]
academic['good'] = fuzz.trapmf(
academic.universe, [65, 70, 100, 100]) # academic score good[65-100]
# Generate trapezoidal fuzzy membership functions
sucsratio['low'] = fuzz.trapmf(sucsratio.universe,
[0, 0, 30, 35]) # academic score weak[0-35]
sucsratio['medium'] = fuzz.trapmf(
sucsratio.universe, [33, 35, 60, 70]) # academic score medium[33-70]
sucsratio['high'] = fuzz.trapmf(
sucsratio.universe,
[65, 70, 100, 100]) # academic score medium[65-100]
# You can see how these look with .view()
#skill.view()
# plt.savefig("Graphs/Skill_MF.pdf") # to save figue in to PDF format
# plt.savefig("Graphs/Skill_MF.png") # to save figue in to PNG format
# You can see how these look with .view()
#academic.view()
# plt.savefig("Graphs/Academic_MF.pdf") # to save figue in to PDF format
# plt.savefig("Graphs/Academic_MF.png") # to save figue in to PNG format
# You can see how these look with .view()
# sucsratio.view()
# plt.savefig("Graphs/Success_rate_MF.pdf") # to save figue in to PDF format
# plt.savefig("Graphs/Succeess_rate_MF.png") # to save figue in to PNG format
# Fuzzy rules
rule1 = ctrl.Rule(academic['good'] & skill['good'], sucsratio['high'])
rule2 = ctrl.Rule(academic['good'] & skill['average'], sucsratio['high'])
rule3 = ctrl.Rule(academic['average'] & skill['average'],
sucsratio['medium'])
rule4 = ctrl.Rule(academic['average'] & skill['good'], sucsratio['medium'])
rule5 = ctrl.Rule(academic['poor'] | skill['poor'], sucsratio['low'])
# Control System Creation and Simulation
# Now that we have our rules defined, we can simply create a control system
sucs_rate_ctrl = ctrl.ControlSystem([rule1, rule2, rule3, rule4, rule5])
"""
In order to simulate this control system, we will create a
"ControlSystemSimulation" : Think of this object representing our controller applied to a specific set of cirucmstances.
"""
sucs_rate_final = ctrl.ControlSystemSimulation(sucs_rate_ctrl)
"""
We can now simulate our control system by simply specifying the inputs
and calling the ``compute`` method.
"""
# 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)
sucs_rate_final.input['academic'] = sb
sucs_rate_final.input['skill'] = sk
# Crunch the numbers
sucs_rate_final.compute()
ans = round(sucs_rate_final.output['success'], 4)
# view results and print results
print("Success Rate:", ans)
update_scs_rate(ans, crf)
def sistema(input_altitude_real: int, input_altitude_relativa: int,
metodo_defuzz: str, graficos: bool) -> float:
"""
O sistema inteiro foi contido em uma função para facilitar sua reutilização,
necessitando apenas dos dados de entrada essenciais
"""
# Variáveis de entrada abstraídas a partir das caracterísitcas e necessidades
# da aeronave
altitude_real = control.Antecedent(numpy.arange(0, 1000, 1),
"altitude_real")
altitude_relativa = control.Antecedent(numpy.arange(0, 1000, 1),
"altitude_relativa")
# Variável de saída para controle dos equipamentos da aeronave
velocidade = control.Consequent(numpy.arange(0, 100, 1),
"velocidade",
defuzzify_method=metodo_defuzz)
# Não utilizada devido à ausência de asa em quadrimotores
# angulo_asa = control.Antecedent(numpy.arange(0, 90, 0.1), "angulo_asa")
# Interpretação da variável de altitude real da aeronave
# Essa variavel representa a altitude do veículo em relação ao nível do mar
altitude_real["baixa"] = skfuzzy.trimf(altitude_real.universe, [0, 0, 250])
altitude_real["media"] = skfuzzy.trapmf(altitude_real.universe,
[200, 250, 500, 550])
altitude_real["alta"] = skfuzzy.trimf(altitude_real.universe,
[500, 600, 700])
altitude_real["muito_alta"] = skfuzzy.trimf(altitude_real.universe,
[650, 1000, 1000])
# Interpretação da variável de altitude relativa da aeronave
# Essa variavel representa a altitude do veículo em relção ao solo diretamente abaixo
altitude_relativa["baixa"] = skfuzzy.trimf(altitude_real.universe,
[0, 0, 200])
altitude_relativa["media"] = skfuzzy.trapmf(altitude_real.universe,
[150, 300, 500, 550])
altitude_relativa["alta"] = skfuzzy.trimf(altitude_real.universe,
[500, 1000, 1000])
# Interpretação da variável de velocidade dos motores da aeronave
velocidade["baixa"] = skfuzzy.trimf(velocidade.universe, [0, 0, 50])
velocidade["media"] = skfuzzy.trimf(velocidade.universe, [25, 50, 75])
velocidade["alta"] = skfuzzy.trimf(velocidade.universe, [75, 100, 100])
# Regras para o controle de velocidade a partir das medições de altitude
# Conjunto 1 - Tratando das condições de baixa e média altitudes reais
regra_1 = control.Rule(
altitude_relativa["baixa"] &
(altitude_real["baixa"] | altitude_real["media"]), velocidade["alta"])
regra_2 = control.Rule(
altitude_relativa["media"] &
(altitude_real["baixa"] | altitude_real["media"]), velocidade["media"])
regra_3 = control.Rule(
altitude_relativa["alta"] &
(altitude_real["baixa"] | altitude_real["media"]
| altitude_real["alta"]), velocidade["baixa"])
# Conjunto 2 - Tratando das condições de alta altitude real
regra_4 = control.Rule(altitude_relativa["baixa"] & altitude_real["alta"],
velocidade["media"])
regra_5 = control.Rule(altitude_relativa["media"] & altitude_real["alta"],
velocidade["media"])
# Conjunto 3 - Tratando das condições de altitude real muito alta
regra_6 = control.Rule(
altitude_relativa["baixa"] & altitude_real["muito_alta"],
velocidade["baixa"])
regra_7 = control.Rule(
altitude_relativa["media"] & altitude_real["muito_alta"],
velocidade["baixa"])
# Construindo o sistema de regras
controle_velocidade = control.ControlSystem(
[regra_1, regra_2, regra_3, regra_4, regra_5, regra_6, regra_7])
simulacao_velocidade = control.ControlSystemSimulation(controle_velocidade)
# Inserção dos valores de entrada a serem processados
simulacao_velocidade.input["altitude_real"] = input_altitude_real
simulacao_velocidade.input["altitude_relativa"] = input_altitude_relativa
# Realizando computação do modelo construído
simulacao_velocidade.compute()
# Exibição dos gráficos de entrada e saída do modelo Fuzzy
if graficos:
altitude_real.view()
altitude_relativa.view()
velocidade.view()
velocidade.view(sim=simulacao_velocidade)
return simulacao_velocidade.output["velocidade"]
click=clicks3x3[i]
time=time3x3[i]
avgclick=time/click
list2=list()
list2.append(0.0)
# list3=np.array(sp.random.uniform(mindif,avgclick,(click-2)))
# print(list3)
for j in range(0,click-2):
rand=np.random.uniform(j*avgclick,(j+1)*avgclick)
list2.append(rand)
list2.append(time)
print(list2)
#fuzzy
time=ctrl.Antecedent(np.arange(30,70,1),'time')
iq=ctrl.Consequent(np.arange(70,200,1),'iq')
time.automf(5)
time.view()
iq['normal']=fuzz.gaussmf(iq.universe,115,4)
iq['superior']=fuzz.gaussmf(iq.universe,130,4)
iq['very superior']=fuzz.gaussmf(iq.universe,145,4)
iq['dullness']=fuzz.gaussmf(iq.universe,85,4)
iq['mensa level']=fuzz.gaussmf(iq.universe,200,4)
iq.view()
rule1=ctrl.Rule(time['poor'],iq['mensa level'])
rule2=ctrl.Rule(time['mediocre'],iq['very superior'])
rule3=ctrl.Rule(time['average'],iq['superior'])
rule4=ctrl.Rule(time['decent'],iq['normal'])
def __init__(self):
evoparation = ctrl.Antecedent(
np.arange(0, 15, 0.2),
'evoparation') # chia độ bốc hơi từ 0-15 với khoảng cách 0.1
humidity = ctrl.Antecedent(
np.arange(0, 100, 0.2),
'humidity') # chia độ ẩm từ 0-100(%) với khoảng cách 0.2
pressure = ctrl.Antecedent(
np.arange(990, 1030, 0.1), 'pressure'
) # chia áp suất từ 990-1020(.10^2 Pa) với khoảng cách 0.1
cloud = ctrl.Antecedent(np.arange(0, 8, 1),
'cloud') # chia mây từ 0-8 với khoảng cách 1
temp = ctrl.Antecedent(
np.arange(15, 40, 0.1),
'temp') # chia nhiệt độ từ 15-38(độ C) với khoảng cách 0.1
rainfall = ctrl.Consequent(
np.arange(0, 120, 0.2),
'rainfall') # chia lượng mưa từ 0-120(mm) với khoảng cách 0.2
evoparation['low'] = fz.trapmf(
evoparation.universe, [0, 0, 3, 4]) # độ bốc hơi thấp => mưa nhiều
evoparation['medium'] = fz.trapmf(evoparation.universe,
[3.4, 4, 7, 10])
evoparation['high'] = fz.trapmf(
evoparation.universe,
[8, 12, 15, 15]) # độ bốc hơi quá cao => mưa nhiều
humidity['low'] = fz.trapmf(humidity.universe, [0, 0, 60, 75])
humidity['high'] = fz.trapmf(humidity.universe,
[65, 80, 100, 100]) # độ ẩm cao mưa nhiều
pressure['low'] = fz.trapmf(
pressure.universe,
[990, 990, 1009, 1012]) # áp suất thấp mưa nhiều
pressure['high'] = fz.trapmf(pressure.universe,
[1009, 1012, 1030, 1030])
cloud['low'] = fz.trapmf(cloud.universe, [0, 0, 5, 7])
cloud['high'] = fz.trapmf(cloud.universe,
[6, 7, 8, 8]) # nhiều mây mưa nhiều
temp['low'] = fz.trapmf(temp.universe, [15, 15, 20, 24.2])
temp['medium'] = fz.trapmf(
temp.universe, [23, 25, 29, 32]) # nhiệt độ TB thì mưa cao hơn
temp['high'] = fz.trapmf(temp.universe, [28.5, 35, 40, 40])
rainfall['very_low'] = fz.trapmf(rainfall.universe,
[0, 0, 2, 4]) # không mưa
rainfall['low'] = fz.trapmf(rainfall.universe, [3, 5, 8, 12]) # mưa ít
rainfall['medium'] = fz.trapmf(rainfall.universe, [10, 15, 35, 40])
rainfall['high'] = fz.trapmf(rainfall.universe,
[35, 45, 120, 120]) # mưa nhiều
rules = [
ctrl.Rule(
evoparation['low'] & temp['low'] & humidity['low']
& pressure['high'] & cloud['low'],
rainfall['very_low']), # tại bốc hơi thấp
ctrl.Rule(
evoparation['low'] & temp['low'] & humidity['low']
& pressure['high'] & cloud['high'],
rainfall['very_low']), # nhiệt độ thấp
ctrl.Rule(
evoparation['low'] & temp['low'] & humidity['low']
& pressure['low'] & cloud['low'], rainfall['very_low']),
ctrl.Rule(
evoparation['low'] & temp['low'] & humidity['low']
& pressure['low'] & cloud['high'], rainfall['very_low']),
ctrl.Rule(
evoparation['low'] & temp['low'] & humidity['high']
& pressure['high'] & cloud['low'], rainfall['very_low']),
ctrl.Rule(
evoparation['low'] & temp['low'] & humidity['high']
& pressure['high'] & cloud['high'], rainfall['very_low']),
ctrl.Rule(
evoparation['low'] & temp['low'] & humidity['high']
& pressure['low'] & cloud['low'], rainfall['very_low']),
ctrl.Rule(
evoparation['low'] & temp['low'] & humidity['high']
& pressure['low'] & cloud['high'], rainfall['low']),
ctrl.Rule(
evoparation['medium'] & temp['low'] & humidity['low']
& pressure['high'] & cloud['low'],
rainfall['very_low']), # tại bốc hơi TB
ctrl.Rule(
evoparation['medium'] & temp['low'] & humidity['low']
& pressure['high'] & cloud['high'],
rainfall['very_low']), # nhiệt độ thấp
ctrl.Rule(
evoparation['medium'] & temp['low'] & humidity['low']
& pressure['low'] & cloud['low'], rainfall['very_low']),
ctrl.Rule(
evoparation['medium'] & temp['low'] & humidity['low']
& pressure['low'] & cloud['high'], rainfall['very_low']),
ctrl.Rule(
evoparation['medium'] & temp['low'] & humidity['high']
& pressure['high'] & cloud['low'], rainfall['very_low']),
ctrl.Rule(
evoparation['medium'] & temp['low'] & humidity['high']
& pressure['high'] & cloud['high'], rainfall['very_low']),
ctrl.Rule(
evoparation['medium'] & temp['low'] & humidity['high']
& pressure['low'] & cloud['low'], rainfall['very_low']),
ctrl.Rule(
evoparation['medium'] & temp['low'] & humidity['high']
& pressure['low'] & cloud['high'], rainfall['low']),
ctrl.Rule(
evoparation['high'] & temp['low'] & humidity['low']
& pressure['high'] & cloud['low'],
rainfall['very_low']), # tại bốc hơi cao
ctrl.Rule(
evoparation['high'] & temp['low'] & humidity['low']
& pressure['high'] & cloud['high'],
rainfall['very_low']), # nhiệt độ thấp
ctrl.Rule(
evoparation['high'] & temp['low'] & humidity['low']
& pressure['low'] & cloud['low'], rainfall['very_low']),
ctrl.Rule(
evoparation['high'] & temp['low'] & humidity['low']
& pressure['low'] & cloud['high'], rainfall['very_low']),
ctrl.Rule(
evoparation['high'] & temp['low'] & humidity['high']
& pressure['high'] & cloud['low'], rainfall['very_low']),
ctrl.Rule(
evoparation['high'] & temp['low'] & humidity['high']
& pressure['high'] & cloud['high'], rainfall['very_low']),
ctrl.Rule(
evoparation['high'] & temp['low'] & humidity['high']
& pressure['low'] & cloud['low'], rainfall['very_low']),
ctrl.Rule(
evoparation['high'] & temp['low'] & humidity['high']
& pressure['low'] & cloud['high'], rainfall['low']),
ctrl.Rule(
evoparation['low'] & temp['medium'] & humidity['low']
& pressure['high'] & cloud['low'],
rainfall['very_low']), # tại bốc hơi thấp
ctrl.Rule(
evoparation['low'] & temp['medium'] & humidity['low']
& pressure['high'] & cloud['high'],
rainfall['very_low']), # nhiệt độ TB
ctrl.Rule(
evoparation['low'] & temp['medium'] & humidity['low']
& pressure['low'] & cloud['low'], rainfall['very_low']),
ctrl.Rule(
evoparation['low'] & temp['medium'] & humidity['low']
& pressure['low'] & cloud['high'], rainfall['very_low']),
ctrl.Rule(
evoparation['low'] & temp['medium'] & humidity['high']
& pressure['high'] & cloud['low'], rainfall['very_low']),
ctrl.Rule(
evoparation['low'] & temp['medium'] & humidity['high']
& pressure['high'] & cloud['high'], rainfall['low']),
ctrl.Rule(
evoparation['low'] & temp['medium'] & humidity['high']
& pressure['low'] & cloud['low'], rainfall['low']),
ctrl.Rule(
evoparation['low'] & temp['medium'] & humidity['high']
& pressure['low'] & cloud['high'], rainfall['medium']),
ctrl.Rule(
evoparation['medium'] & temp['medium'] & humidity['low']
& pressure['high'] & cloud['low'],
rainfall['very_low']), # tại bốc hơi TB
ctrl.Rule(
evoparation['medium'] & temp['medium'] & humidity['low']
& pressure['high'] & cloud['high'],
rainfall['very_low']), # nhiệt độ TB
ctrl.Rule(
evoparation['medium'] & temp['medium'] & humidity['low']
& pressure['low'] & cloud['low'], rainfall['very_low']),
ctrl.Rule(
evoparation['medium'] & temp['medium'] & humidity['low']
& pressure['low'] & cloud['high'], rainfall['very_low']),
ctrl.Rule(
evoparation['medium'] & temp['medium'] & humidity['high']
& pressure['high'] & cloud['low'], rainfall['very_low']),
ctrl.Rule(
evoparation['medium'] & temp['medium'] & humidity['high']
& pressure['high'] & cloud['high'], rainfall['low']),
ctrl.Rule(
evoparation['medium'] & temp['medium'] & humidity['high']
& pressure['low'] & cloud['low'], rainfall['low']),
ctrl.Rule(
evoparation['medium'] & temp['medium'] & humidity['high']
& pressure['low'] & cloud['high'], rainfall['low']),
ctrl.Rule(
evoparation['high'] & temp['medium'] & humidity['low']
& pressure['high'] & cloud['low'],
rainfall['very_low']), # tại bốc hơi cao
ctrl.Rule(
evoparation['high'] & temp['medium'] & humidity['low']
& pressure['high'] & cloud['high'],
rainfall['very_low']), # nhiệt độ TB
ctrl.Rule(
evoparation['high'] & temp['medium'] & humidity['low']
& pressure['low'] & cloud['low'], rainfall['very_low']),
ctrl.Rule(
evoparation['high'] & temp['medium'] & humidity['low']
& pressure['low'] & cloud['high'], rainfall['very_low']),
ctrl.Rule(
evoparation['high'] & temp['medium'] & humidity['high']
& pressure['high'] & cloud['low'], rainfall['very_low']),
ctrl.Rule(
evoparation['high'] & temp['medium'] & humidity['high']
& pressure['high'] & cloud['high'], rainfall['low']),
ctrl.Rule(
evoparation['high'] & temp['medium'] & humidity['high']
& pressure['low'] & cloud['low'], rainfall['low']),
ctrl.Rule(
evoparation['high'] & temp['medium'] & humidity['high']
& pressure['low'] & cloud['high'], rainfall['high']),
ctrl.Rule(
evoparation['low'] & temp['high'] & humidity['low']
& pressure['high'] & cloud['low'],
rainfall['very_low']), # tại bốc hơi thấp
ctrl.Rule(
evoparation['low'] & temp['high'] & humidity['low']
& pressure['high'] & cloud['high'],
rainfall['very_low']), # nhiệt độ cao
ctrl.Rule(
evoparation['low'] & temp['high'] & humidity['low']
& pressure['low'] & cloud['low'], rainfall['very_low']),
ctrl.Rule(
evoparation['low'] & temp['high'] & humidity['low']
& pressure['low'] & cloud['high'], rainfall['very_low']),
ctrl.Rule(
evoparation['low'] & temp['high'] & humidity['high']
& pressure['high'] & cloud['low'], rainfall['very_low']),
ctrl.Rule(
evoparation['low'] & temp['high'] & humidity['high']
& pressure['high'] & cloud['high'], rainfall['very_low']),
ctrl.Rule(
evoparation['low'] & temp['high'] & humidity['high']
& pressure['low'] & cloud['low'], rainfall['very_low']),
ctrl.Rule(
evoparation['low'] & temp['high'] & humidity['high']
& pressure['low'] & cloud['high'], rainfall['low']),
ctrl.Rule(
evoparation['medium'] & temp['high'] & humidity['low']
& pressure['high'] & cloud['low'],
rainfall['very_low']), # tại bốc hơi TB
ctrl.Rule(
evoparation['medium'] & temp['high'] & humidity['low']
& pressure['high'] & cloud['high'],
rainfall['very_low']), # nhiệt độ cao
ctrl.Rule(
evoparation['medium'] & temp['high'] & humidity['low']
& pressure['low'] & cloud['low'], rainfall['very_low']),
ctrl.Rule(
evoparation['medium'] & temp['high'] & humidity['low']
& pressure['low'] & cloud['high'], rainfall['very_low']),
ctrl.Rule(
evoparation['medium'] & temp['high'] & humidity['high']
& pressure['high'] & cloud['low'], rainfall['very_low']),
ctrl.Rule(
evoparation['medium'] & temp['high'] & humidity['high']
& pressure['high'] & cloud['high'], rainfall['very_low']),
ctrl.Rule(
evoparation['medium'] & temp['high'] & humidity['high']
& pressure['low'] & cloud['low'], rainfall['very_low']),
ctrl.Rule(
evoparation['medium'] & temp['high'] & humidity['high']
& pressure['low'] & cloud['high'], rainfall['low']),
ctrl.Rule(
evoparation['high'] & temp['high'] & humidity['low']
& pressure['high'] & cloud['low'],
rainfall['very_low']), # tại bốc hơi cao
ctrl.Rule(
evoparation['high'] & temp['high'] & humidity['low']
& pressure['high'] & cloud['high'],
rainfall['very_low']), # nhiệt độ cao
ctrl.Rule(
evoparation['high'] & temp['high'] & humidity['low']
& pressure['low'] & cloud['low'], rainfall['very_low']),
ctrl.Rule(
evoparation['high'] & temp['high'] & humidity['low']
& pressure['low'] & cloud['high'], rainfall['very_low']),
ctrl.Rule(
evoparation['high'] & temp['high'] & humidity['high']
& pressure['high'] & cloud['low'], rainfall['very_low']),
ctrl.Rule(
evoparation['high'] & temp['high'] & humidity['high']
& pressure['high'] & cloud['high'], rainfall['very_low']),
ctrl.Rule(
evoparation['high'] & temp['high'] & humidity['high']
& pressure['low'] & cloud['low'], rainfall['very_low']),
ctrl.Rule(
evoparation['high'] & temp['high'] & humidity['high']
& pressure['low'] & cloud['high'], rainfall['low']),
]
CT = ctrl.ControlSystem(rules)
self.Defz = ctrl.ControlSystemSimulation(CT)
def run_fuzzy_system(tightness, aggressiveness, money_opponent, money_player,
probability_hand):
# Compute risk aversion opponent
# Input: tightness and aggressiveness of the opponent
# Output: risk aversive behavior of the opponent
tight = np.arange(0, 1, 0.1)
x_aggress = np.arange(0, 1, 0.1)
x_risk_av = np.arange(0, 1, 0.1)
# Risk = [tight, x_aggress, x_risk_av]
# risk_members = compute_memberships(Risk, [0, 0.5, 1])
# aversion, risk0, aggregated= fuzzy_inference(Risk, tightness, aggressiveness, risk_members, "risk")
# titles = ["Tightness opponent", "Aggressiveness opponent", "Risk aversive behavior"]
# Compute optimal strategy player
# Input: quality cards opponent and odds player
# Ouput: indication of optimal strategy for player
aggressiveness_opponent = ctrl.Antecedent(np.arange(0, 1.1, 0.1),
'aggressiveness')
aggressiveness_opponent['low'] = fuzz.trimf(
aggressiveness_opponent.universe, [0, 0, 0.5])
aggressiveness_opponent['medium'] = fuzz.trimf(
aggressiveness_opponent.universe, [0, 0.5, 1])
aggressiveness_opponent['high'] = fuzz.trimf(
aggressiveness_opponent.universe, [0.5, 1, 1])
tightness_opponent = ctrl.Antecedent(np.arange(0, 1.1, 0.1),
'tightness_opponent')
tightness_opponent['low'] = fuzz.trimf(tightness_opponent.universe,
[0, 0, 0.5])
tightness_opponent['medium'] = fuzz.trimf(tightness_opponent.universe,
[0, 0.5, 1])
tightness_opponent['high'] = fuzz.trimf(tightness_opponent.universe,
[0.5, 1, 1])
risk_aversion = ctrl.Consequent(np.arange(0, 1.1, 0.1), 'risk_aversion')
risk_aversion['low'] = fuzz.trimf(risk_aversion.universe, [0, 0, 0.5])
risk_aversion['medium'] = fuzz.trimf(risk_aversion.universe, [0, 0.5, 1])
risk_aversion['high'] = fuzz.trimf(risk_aversion.universe, [0.5, 1, 1])
rules = []
rules.append(
ctrl.Rule(tightness_opponent['low'] & aggressiveness_opponent['low'],
risk_aversion['medium']))
rules.append(
ctrl.Rule(
tightness_opponent['low'] & aggressiveness_opponent['medium'],
risk_aversion['low']))
rules.append(
ctrl.Rule(tightness_opponent['low'] & aggressiveness_opponent['high'],
risk_aversion['low']))
rules.append(
ctrl.Rule(
tightness_opponent['medium'] & aggressiveness_opponent['low'],
risk_aversion['high']))
rules.append(
ctrl.Rule(
tightness_opponent['medium'] & aggressiveness_opponent['medium'],
risk_aversion['medium']))
rules.append(
ctrl.Rule(
tightness_opponent['medium'] & aggressiveness_opponent['high'],
risk_aversion['low']))
rules.append(
ctrl.Rule(tightness_opponent['high'] & aggressiveness_opponent['low'],
risk_aversion['high']))
rules.append(
ctrl.Rule(
tightness_opponent['high'] & aggressiveness_opponent['medium'],
risk_aversion['high']))
rules.append(
ctrl.Rule(tightness_opponent['high'] & aggressiveness_opponent['high'],
risk_aversion['medium']))
aversion_ctrl = ctrl.ControlSystem(rules)
risk_averse = ctrl.ControlSystemSimulation(aversion_ctrl)
risk_averse.input['aggressiveness'] = aggressiveness
risk_averse.input['tightness_opponent'] = tightness
risk_averse.compute()
aversion = risk_averse.output['risk_aversion']
# Compute quality cards opponent
# Input: risk aversive behavior and money left opponent
# Output: estimation of the quality of the cards of opponent
x_left_opponent = np.arange(0, 1, 0.1)
x_quality = np.arange(0, 1, 0.1)
Quality = [x_risk_av, x_left_opponent, x_quality]
quality_members = compute_memberships(Quality, [0, 0.5, 1])
quality_cards_opponent_out, risk0, aggregated = fuzzy_inference(
Quality, aversion, money_opponent, quality_members, "quality")
titles = [
"Risk aversion opponent", "Money left opponent ",
"Quality cards opponent"
]
#visualize_memberships(Quality, quality_members[0], quality_members[1], quality_members[2], titles)
#visualize_result(Quality, quality_members[2], risk0, aggregated, quality_cards_opponent)
# print("quality", quality_cards_opponent_out)
# # Compute odds player
# # Input: probability hand of hand player and money left player
# # Ouput: estimation of how good the players chances are
# probability= np.arange(0, 1, 0.1)
# money_left_player = np.arange(0, 1, 0.1)
# player_odds = np.arange(0, 1, 0.1)
# Odds = [probability, money_left_player, player_odds ]
# odds_members = compute_memberships(Odds, [0, 0.5, 1])
# odds_player_out, risk0, aggregated = fuzzy_inference(Odds, probability_hand, money_player, odds_members, "odds")
# titles = ["Probability hand", "Money left player", "Odds player"]
# #visualize_memberships(Odds, odds_members[0], odds_members[1], odds_members[2], titles)
# #visualize_result(Odds, odds_members[2], risk0, aggregated, odds_player)
# # print("odds", odds_player_out)
# Compute optimal strategy player
# Input: quality cards opponent and odds player and aggressiveness_opponent
# Ouput: indication of optimal strategy for player
quality_cards_opponent = ctrl.Antecedent(np.arange(0, 1.1, 0.1),
'quality_cards_opponent')
quality_cards_opponent['low'] = fuzz.trimf(quality_cards_opponent.universe,
[0, 0, 0.5])
quality_cards_opponent['medium'] = fuzz.trimf(
quality_cards_opponent.universe, [0, 0.5, 1])
quality_cards_opponent['high'] = fuzz.trimf(
quality_cards_opponent.universe, [0.5, 1, 1])
odds_player = ctrl.Antecedent(np.arange(0, 1.1, 0.1), 'odds_player')
odds_player['low'] = fuzz.trimf(odds_player.universe, [0, 0, 0.5])
odds_player['medium'] = fuzz.trimf(odds_player.universe, [0, 0.5, 1])
odds_player['high'] = fuzz.trimf(odds_player.universe, [0.5, 1, 1])
strategy_optimal = ctrl.Consequent(np.arange(0, 1.1, 0.1),
'strategy_optimal')
strategy_optimal['fold'] = fuzz.trimf(strategy_optimal.universe,
[0, 0, 0.5])
strategy_optimal['call'] = fuzz.trimf(strategy_optimal.universe,
[0, 0.5, 1])
strategy_optimal['raise'] = fuzz.trimf(strategy_optimal.universe,
[0.5, 1, 1])
rules = []
rules.append(
ctrl.Rule(
odds_player['low'] & quality_cards_opponent['low']
& aggressiveness_opponent['low'], strategy_optimal['call']))
rules.append(
ctrl.Rule(
odds_player['low'] & quality_cards_opponent['low']
& aggressiveness_opponent['medium'], strategy_optimal['call']))
rules.append(
ctrl.Rule(
odds_player['low'] & quality_cards_opponent['low']
& aggressiveness_opponent['high'], strategy_optimal['raise']))
rules.append(
ctrl.Rule(odds_player['low'] & quality_cards_opponent['medium'],
strategy_optimal['fold']))
rules.append(
ctrl.Rule(odds_player['low'] & quality_cards_opponent['high'],
strategy_optimal['fold']))
rules.append(
ctrl.Rule(odds_player['medium'] & quality_cards_opponent['low'],
strategy_optimal['call']))
rules.append(
ctrl.Rule(odds_player['medium'] & quality_cards_opponent['medium'],
strategy_optimal['raise']))
rules.append(
ctrl.Rule(odds_player['medium'] & quality_cards_opponent['high'],
strategy_optimal['fold']))
rules.append(
ctrl.Rule(odds_player['high'] & quality_cards_opponent['low'],
strategy_optimal['call']))
rules.append(
ctrl.Rule(odds_player['high'] & quality_cards_opponent['medium'],
strategy_optimal['raise']))
rules.append(
ctrl.Rule(odds_player['high'] & quality_cards_opponent['high'],
strategy_optimal['raise']))
rules.append(
ctrl.Rule(
odds_player['high'] & quality_cards_opponent['low']
& aggressiveness_opponent['high'], strategy_optimal['raise']))
rules.append(
ctrl.Rule(
odds_player['high'] & quality_cards_opponent['medium']
& aggressiveness_opponent['high'], strategy_optimal['raise']))
rules.append(
ctrl.Rule(
odds_player['high'] & quality_cards_opponent['high']
& aggressiveness_opponent['high'], strategy_optimal['raise']))
rules.append(ctrl.Rule(odds_player['low'], strategy_optimal['raise']))
strategy_ctrl = ctrl.ControlSystem(rules)
strategize = ctrl.ControlSystemSimulation(strategy_ctrl)
strategize.input['aggressiveness'] = aggressiveness
strategize.input['odds_player'] = probability_hand
strategize.input['quality_cards_opponent'] = quality_cards_opponent_out
strategize.compute()
optimal = strategize.output['strategy_optimal']
# strategy_optimal.view(sim=strategize)
optimal = get_move_and_degree(optimal, strategy_optimal.universe)
return optimal
# Scaling champions stats to 0.0-1.0
for i, max_stat in enumerate(max_stats_list):
df[df.columns[i + 1]] = df[df.columns[i + 1]] / max_stat
print(df[df.columns[i + 1]])
print("The end of this stat")
hp_fuzzy = ctrl.Antecedent(np.arange(0, 1.01, 0.01), "hp_fuzzy")
mean_hp_fuzzy = ctrl.Antecedent(np.arange(0, 1.01, 0.01), "mean_hp_fuzzy")
points_fuzzy = ctrl.Consequent(np.arange(0, 1.01, 0.01), "points_fuzzy")
hp_fuzzy["poor"] = fuzz.gbellmf(hp_fuzzy.universe, 0.025, 0.95, 0.2)
hp_fuzzy["mediocre"] = fuzz.gbellmf(hp_fuzzy.universe, 0.025, 0.95, 0.4)
hp_fuzzy["average"] = fuzz.gbellmf(hp_fuzzy.universe, 0.025, 0.95, 0.6)
hp_fuzzy["decent"] = fuzz.gbellmf(hp_fuzzy.universe, 0.025, 0.95, 0.8)
hp_fuzzy["good"] = fuzz.gbellmf(hp_fuzzy.universe, 0.025, 0.95, 1.0)
mean_hp_fuzzy["poor"] = fuzz.gbellmf(mean_hp_fuzzy.universe, 0.025, 0.95, 0.2)
mean_hp_fuzzy["mediocre"] = fuzz.gbellmf(mean_hp_fuzzy.universe, 0.025, 0.95, 0.4)
mean_hp_fuzzy["average"] = fuzz.gbellmf(mean_hp_fuzzy.universe, 0.025, 0.95, 0.6)
mean_hp_fuzzy["decent"] = fuzz.gbellmf(mean_hp_fuzzy.universe, 0.025, 0.95, 0.8)
mean_hp_fuzzy["good"] = fuzz.gbellmf(mean_hp_fuzzy.universe, 0.025, 0.95, 1.0)
# -------------------------------------------------------- # Sistema fuzzy exemplo # Controle de velocidade baseado na leitura da distancia # -------------------------------------------------------- import skfuzzy as fuzzy import numpy as np from skfuzzy import control as ctrl # -------------------------------------------------------- # Definição dos conjuntos universo (entrada e saída) # -------------------------------------------------------- distancia = ctrl.Antecedent(np.arange(0, 80, 1), 'Distancia') velocidade = ctrl.Consequent(np.arange(0, 255, 1), 'Velocidade') # -------------------------------------------------------- # Definição dos conjuntos fuzzy # -------------------------------------------------------- distancia['Perto'] = fuzzy.trimf(distancia.universe, [0, 10, 20]) distancia['Longe'] = fuzzy.trimf(distancia.universe, [18, 30, 50]) distancia['Muito longe'] = fuzzy.trimf(distancia.universe, [48, 60, 85]) # Mostrar gráfico da distancia distancia.view() velocidade['Lento'] = fuzzy.trimf(velocidade.universe, [0, 100, 150]) velocidade['Rapido'] = fuzzy.trimf(velocidade.universe, [140, 170, 190]) velocidade['Muito rapido'] = fuzzy.trimf(velocidade.universe, [180, 220, 255]) # Mostrar gráfico da velocidade velocidade.view()
from skfuzzy import control as ctrl
import csv
#s = input("Enter Speed:(-1 to leave Open):" )
#h = input("Enter Hardness:(-1 to leave Open):" )
#w = input("Enter Width:(-1 to leave Open):" )
#f = input("Enter Feed:(-1 to leave Open):" )
#Input Variables
speed = ctrl.Antecedent(np.arange(1, 100, 1), 'speed')
hardness = ctrl.Antecedent(np.arange(30, 40, 1), 'hardness')
width = ctrl.Antecedent(np.arange(0.05, 0.20, 0.01), 'width')
feed = ctrl.Antecedent(np.arange(1, 5, 1), 'feed')
amr = ctrl.Antecedent(np.arange(0, 5000, 50), 'amr')
#Output Variables
energy = ctrl.Consequent(np.arange(0, 500, 5), 'energy')
scenergy = ctrl.Consequent(np.arange(0, 10, 0.1), 'scenergy')
mrr = ctrl.Consequent(np.arange(0, 1000, 5), 'mrr')
vb = ctrl.Consequent(np.arange(0, 0.2, 0.0005), 'vb')
vb3 = ctrl.Consequent(np.arange(0, 0.2, 0.0005), 'vb3')
avgstatcutforce = ctrl.Consequent(np.arange(0, 1500, 10), 'avgstatcutforce')
avgdynfeedforce = ctrl.Consequent(np.arange(0, 1300, 10), 'avgdynfeedforce')
#input fuzzysets
#speed
speed['slow'] = fuzz.trapmf(speed.universe, [1, 1, 28, 57])
speed['medium'] = fuzz.trimf(speed.universe, [28, 57, 89])
speed['fast'] = fuzz.trapmf(speed.universe, [57, 89, 100, 100])
#feed
feed['small'] = fuzz.trapmf(feed.universe, [0.05, 0.05, 0.07, 0.12])
feed['medium'] = fuzz.trimf(feed.universe, [0.07, 0.12, 0.17])
HBeAg['POSITIVA'] = fuzz.trimf(HBeAg.universe, [0.65, 0.8, 1.2]) Anti_HBeAg= ctrl.Antecedent(np.arange(0, 1.51, 0.01),'Anti_HBeAg') Anti_HBeAg['POSITIVA'] = fuzz.trimf(Anti_HBeAg.universe, [0, 0.4, 0.85]) Anti_HBeAg['NEGATIVA'] = fuzz.trimf(Anti_HBeAg.universe, [0.75, 1.1, 1.5]) HBV_DNA= ctrl.Antecedent(np.arange(0, 20.5, 0.5),'HBV_DNA') HBV_DNA['NEGATIVA'] = fuzz.trimf(HBV_DNA.universe, [0, 5.5, 10.5]) HBV_DNA['POSITIVA'] = fuzz.trimf(HBV_DNA.universe, [9.5, 15.5, 20]) #consecuentes DBH = ctrl.Consequent(np.arange(0, 1.01, 0.01), 'DBH') DBH['NO HEPATITIS'] = fuzz.trimf(DBH.universe, [0, 0, 0.25]) DBH['HEPATITIS AGUDA'] = fuzz.trimf(DBH.universe, [0, 0.25, 0.5]) DBH['HEPATITIS CRONICA'] = fuzz.trimf(DBH.universe, [0.25, 0.5, 0.75]) DBH['INMUNIDAD POR VACUNACION'] = fuzz.trimf(DBH.universe, [0.5, 0.75,1]) DBH['INMUNIDAD POR INFECCION ANTERIOR'] = fuzz.trimf(DBH.universe, [0.75, 1, 1]) #Pintar los antecedentes AST.view() ALT.view() HBsAg.view() Anti_HBsAg.view() Anti_HBcAg.view() Anti_HBcAg_IgM.view()
import numpy as np import skfuzzy as fuzz from skfuzzy import control as ctrl import Node611 import excel import mcpras import time #Fuzzy Controller Vrefd = ctrl.Consequent(np.arange(-2, 2, 0.1), 'Vrefd') Pdif = ctrl.Antecedent(np.arange(-200, 200, 0.01), 'Pdif') #Membership functions #Pdif Pdif['N'] = fuzz.trapmf(Pdif.universe, [-100, -2, -0.2, -0.01]) Pdif['P'] = fuzz.trapmf(Pdif.universe, [0.01, 0.2, 2, 100]) Pdif['Z'] = fuzz.trimf(Pdif.universe, [-0.01, 0, 0.01]) #Vref Vrefd['N'] = fuzz.trimf(Vrefd.universe, [-0.2, -0.1, 0]) Vrefd['P'] = fuzz.trimf(Vrefd.universe, [0, 0.1, 0.2]) Vrefd['Z'] = fuzz.trimf(Vrefd.universe, [-0.01, 0, 0.01]) ##Rules rule1 = ctrl.Rule(Pdif['P'], Vrefd['P']) rule2 = ctrl.Rule(Pdif['N'], Vrefd['N'])
def adjustment_ctrl(self, new_state, status, latency, servers, ram,
memory):
ram_state = int(ram)
print("RAM STATE (ram):" + str(ram_state))
#The reward calculation is based on scoring the previous action with the reward of the new state, also I should take into consideration all the moments that there is no new regard to add then to the reward
print("Reinforcement Learning Fine Tunning")
if self.step == 0:
#Copy previous value of self not the pointer!!!!
self.last_action = [[[self.array_ram_lo], [self.array_ram_med],
[self.array_ram_hi]], new_state]
print(self.last_action)
self.step += 1
else:
print(self.last_action)
#Reward Calculus
value_reward = 0
#I have to consider also minimum RAM and CPU allocated gives maximum reward
if status >= 500:
value_reward -= status
elif status >= 200 and status < 300:
value_reward += 200
value_reward += (-ram + 400) * 2 #None
value_reward += (100 if servers == 1 else 0)
value_reward += int(-(latency * 10) + 200)
temp = (300 - np.abs(70 - memory) * (30 if memory > 70 else 30))
ref = ((memory - 70) / 20 if memory > 70 else
(memory - 70) / 50) #50
value_reward += temp
self.reward = value_reward #+randint(-25,25)#Adding to reward for testing proposes
print("################")
file.write(
str(status) + "," + str((-ram + 400) * 4) + "," +
str((100 if servers == 1 else 0)) + "," +
str(int(-latency + 200)) + "," + str(self.reward) + "\n")
print("RAM Value:" + str(ram))
print("Reward RAM: " + str((-ram + 400) * 4))
print("Reward Latency: " + str(int(-latency + 200)))
print("Reward Memory: " + str(300 - (np.abs(70 - memory) *
(30 if memory > 70 else 4))))
print("################")
self.step += 1
if 1: #self.step==2:
#self.step=0
#State is a number from 0 to 2 referencing to the possible action taken
#Instead of taking into consideration the rule, I take into consideration the action every time that is performed as each action should be possible
#Aggregation of overall reward after action
#rewards=np.median(self.reward)
rewards = self.reward
#Action
array_parameters_actions = self.last_action[0]
state = self.last_action[1]
action = [array_parameters_actions[state], servers]
#Look for used action
actions_table = [e[0] == action for e in self.q[state]]
actions_table_1 = [
e[0] == [array_parameters_actions[1], servers]
for e in self.q[1]
]
actions_table_0 = [
e[0] == [array_parameters_actions[0], servers]
for e in self.q[0]
]
actions_table_2 = [
e[0] == [array_parameters_actions[2], servers]
for e in self.q[2]
]
if any(actions_table):
#Update reward
self.q[state][actions_table.index(True)][1] = np.median(
[self.q[state][actions_table.index(True)][1], rewards])
else:
#Create new state with new reward
#print("Table")
#print(self.q[state])
(self.q[state]).append([action, rewards])
if self.increase >= 10:
if any(actions_table_1):
#Update reward
self.q[1][actions_table_1.index(True)][1] = np.median([
self.q[1][actions_table_1.index(True)][1], rewards
])
else:
#Create new state with new reward
#print("Table")
#print(self.q[state])
(self.q[1]).append(
[[array_parameters_actions[1], servers], rewards])
if self.increase_state0 >= 10:
if any(actions_table_0):
#Update reward
self.q[0][actions_table_0.index(True)][1] = np.median([
self.q[0][actions_table_0.index(True)][1], rewards
])
else:
#Create new state with new reward
#print("Table")
#print(self.q[state])
(self.q[0]).append(
[[array_parameters_actions[0], servers], rewards])
if any(actions_table_2):
#Update reward
self.q[2][actions_table_2.index(True)][1] = np.median([
self.q[2][actions_table_2.index(True)][1], rewards
])
else:
#Create new state with new reward
#print("Table")
#print(self.q[state])
(self.q[2]).append(
[[array_parameters_actions[2], servers], rewards])
print("Previous State Comprobation: " + str(state))
#Based on overrall performance on the Q table pick the best seed and update the system
position_reward = -1
#For loop best performance
factor = 1.2
state_base = int(state)
#state=0
if state == 0:
self.increase += 1
self.increase_state0 = 0
print("Update State 0")
if len(self.q[state]) < 3:
print("IN-RANDOM 5" if (len(self.q[state]) %
5 == 0) else "")
print("Random Search")
if new_state != 4:
self.array_ram_lo = [
99, 150 + randint(-50, 50), 200
]
else:
print("Random Search on Neutral")
self.array_ram_hi = [
100, 150 + randint(-45, 45), 200
]
else:
print("Random Optimizer based on Reward")
highest_reward = 0
position_reward = 0
for enum, rew_state in enumerate(self.q[state]):
if enum == 0:
highest_reward = rew_state[1] * (enum / len(
self.q[state]) if enum > 15 else 1)
else:
if highest_reward < rew_state[1]:
highest_reward = rew_state[1] * (
enum /
len(self.q[state]) if enum > 15 else 1)
position_reward = enum
if (self.step % 100 != 0):
#discount=(1 if float(len(self.q[state]))/float(factor)<=1 else float(len(self.q[state]))/float(factor))
#if new_state!=4:
#State Modify
#self.array_ram_lo=[self.q[state][position_reward][0][0][0][0]+randint(int(-10)+int(50*ref),int(10)+int(50*ref)),self.q[state][position_reward][0][0][0][1]+(50*ref),self.q[state][position_reward][0][0][0][2]+int(50*ref)]
self.array_ram_lo = [
self.q[state][position_reward][0][0][0][0],
self.q[state][position_reward][0][0][0][1] +
randint(
int(-10) + int(50 * ref),
int(10) + int(50 * ref)),
self.q[state][position_reward][0][0][0][2]
]
if self.increase > 10:
#print("Decreasing")
#print(len(self.q[1]))
#print(self.q[1])
for enum, rew_state in enumerate(self.q[1]):
if enum == 0:
highest_reward = rew_state[1] * (
enum / len(self.q[1])
if enum > 15 else 1) #Memory lose
position_reward = 0
else:
#print(rew_state[1])
if highest_reward < rew_state[1]:
highest_reward = rew_state[1] * (
enum / len(self.q[1]) if enum >
15 else 1) # Memory lose
position_reward = enum
#print(self.q[1][position_reward][0][0][0][0])
self.array_ram_med = [
self.q[1][position_reward][0][0][0][0],
self.q[1][position_reward][0][0][0][1] +
randint(-10 + int(50 * ref),
10 + int(50 * ref)),
self.q[1][position_reward][0][0][0][2]
]
#state=1
elif state == 1:
self.increase = 0
self.increase_state0 += 1
print("Update State 1")
if len(self.q[state]) < 3:
print("IN-RANDOM 5" if (len(self.q[state]) %
5 == 0) else "")
print("Random Search")
if new_state != 4:
self.array_ram_med = [
200, 250 + randint(-50, 50), 300
]
else:
print("Random Search on Neutral")
self.array_ram_hi = [
200, 250 + randint(-45, 45), 300
]
else:
print("///////////////")
print("Random Optimizer based on Reward 1")
highest_reward = 0
position_reward = 0
print("Reward")
for enum, rew_state in enumerate(self.q[state]):
if enum == 0:
highest_reward = rew_state[1] * (
enum / len(self.q[state])
if enum > 15 else 1) #Memory lose
else:
#print(rew_state[1])
if highest_reward < rew_state[1]:
highest_reward = rew_state[1] * (
enum / len(self.q[state])
if enum > 15 else 1) # Memory lose
position_reward = enum
print(highest_reward)
#if (self.step % 100!=0):
#discount= (1 if float(len(self.q[state]))/float(factor)<=1 else float(len(self.q[state]))/float(factor))
#if new_state!=4:
print("Random Add: " + str(ref))
print(
randint(
int(-10) + int(50 * ref),
int(10) + int(50 * ref)))
#if new_state==2:
# ref=-ref
if self.increase_state0 > 13 and self.increase_state0 % 3 == 1:
self.array_ram_med = [
self.q[state][position_reward][0][0][0][0],
self.q[state][position_reward][0][0][0][1] +
randint(
int(-10) + int(50 * ref),
int(10) + int(50 * ref)),
self.q[state][position_reward][0][0][0][2]
]
else:
self.array_ram_med = [
self.q[state][position_reward][0][0][0][0],
self.q[state][position_reward][0][0][0][1] +
randint(0, int(100)),
self.q[state][position_reward][0][0][0][2]
]
if self.increase_state0 > 10:
print("Decreasing")
for enum, rew_state in enumerate(self.q[0]):
if enum == 0:
highest_reward = rew_state[1] * (
enum / len(self.q[0])
if enum > 15 else 1) #Memory lose
position_reward = 0
else:
if highest_reward < rew_state[1]:
highest_reward = rew_state[1] * (
enum / len(self.q[0])
if enum > 15 else 1) # Memory lose
position_reward = enum
self.array_ram_lo = [
self.q[0][position_reward][0][0][0][0],
self.q[0][position_reward][0][0][0][1] +
randint(-10 + int(50 * ref),
10 + int(50 * ref)),
self.q[0][position_reward][0][0][0][2]
]
for enum, rew_state in enumerate(self.q[2]):
if enum == 0:
highest_reward = rew_state[1] * (
enum / len(self.q[2])
if enum > 15 else 1) #Memory lose
position_reward = 0
else:
if highest_reward < rew_state[1]:
highest_reward = rew_state[1] * (
enum / len(self.q[2])
if enum > 15 else 1) # Memory lose
position_reward = enum
self.array_ram_hi = [
self.q[2][position_reward][0][0][0][0],
self.q[2][position_reward][0][0][0][1] +
randint(-10 + int(50 * ref),
10 + int(50 * ref)),
self.q[2][position_reward][0][0][0][2]
]
#state=2
elif state == 2:
print("Update State 2")
self.increase_state0 = 0
if len(self.q[state]) < 3:
print("IN-RANDOM 5" if (len(self.q[state]) %
5 == 0) else "")
print("Random Search")
if new_state != 4:
self.array_ram_hi = [
300, 350 + randint(-50, 50), 400
]
else:
print("Random Search on Neutral")
self.array_ram_hi = [
300, 350 + randint(-45, 45), 400
]
else:
print("Random Optimizer based on Reward")
highest_reward = 0
position_reward = 0
self.increase += 1
for enum, rew_state in enumerate(self.q[state]):
if enum == 0:
highest_reward = rew_state[1] * (enum / len(
self.q[state]) if enum > 15 else 1)
else:
if highest_reward < rew_state[1]:
highest_reward = rew_state[1] * (
enum /
len(self.q[state]) if enum > 15 else 1)
position_reward = enum
if (self.step % 100 != 0):
discount = (1 if float(len(self.q[state])) /
float(factor) <= 1 else
float(len(self.q[state])) /
float(factor))
print("Exploit")
print(self.q[state][position_reward][0][0][0])
print(self.q[state][position_reward][0][0][0][0] +
randint(int(-50 /
discount), int(25 / discount)))
self.array_ram_hi = [
self.q[state][position_reward][0][0][0][0],
self.q[state][position_reward][0][0][0][1] +
randint(
int(-10) + int(50 * ref),
int(10) + int(50 * ref)),
self.q[state][position_reward][0][0][0][2]
]
if self.increase > 10:
print("Increasing")
for enum, rew_state in enumerate(self.q[1]):
if enum == 0:
highest_reward = rew_state[1] * (
enum / len(self.q[1])
if enum > 15 else 1) #Memory lose
position_reward = 0
else:
if highest_reward < rew_state[1]:
highest_reward = rew_state[1] * (
enum / len(self.q[1]) if enum >
15 else 1) # Memory lose
position_reward = enum
self.array_ram_med = [
self.q[1][position_reward][0][0][0][0],
self.q[1][position_reward][0][0][0][1] +
randint(-10 + int(50 * ref),
10 + int(50 * ref)),
self.q[1][position_reward][0][0][0][2]
]
#For this first test Im only going to record the results without trying to work around the explore-exploit problem, as first I would like to see if the logic is already working.
state = int(state_base)
print("Previous State COmprobation: " + str(state))
#print("Q-table")
#print(self.q)
self.file_q_table.write('%s \n' % self.q)
ram = np.arange(100, 351, 1)
print("Variability: " + str(self.variability))
print("State: " + str(state) + ", New State: " +
str(new_state))
print("New Parameters Before Rules")
print(self.array_ram_lo)
print(self.array_ram_med)
print(self.array_ram_hi)
print("##############")
if self.array_ram_hi[1] > self.array_ram_hi[2]:
self.array_ram_hi[1] = self.array_ram_hi[2]
if self.array_ram_hi[0] > self.array_ram_hi[1]:
self.array_ram_hi[1] = self.array_ram_hi[0]
if self.array_ram_med[0] > self.array_ram_med[1]:
self.array_ram_med[1] = self.array_ram_med[0]
if self.array_ram_med[1] > self.array_ram_med[2]:
self.array_ram_med[1] = self.array_ram_med[2]
if self.array_ram_lo[1] > self.array_ram_lo[2]:
self.array_ram_lo[1] = self.array_ram_lo[2]
if self.array_ram_lo[0] > self.array_ram_lo[1]:
self.array_ram_lo[1] = self.array_ram_lo[0]
print("New Parameters After Rules")
print(self.array_ram_lo)
print(self.array_ram_med)
print(self.array_ram_hi)
print("##############")
file_fuzzy.write(
str(self.array_ram_lo[0]) + "," +
str(self.array_ram_lo[1]) + "," +
str(self.array_ram_lo[2]) + "," +
str(self.array_ram_med[0]) + "," +
str(self.array_ram_med[1]) + "," +
str(self.array_ram_med[2]) + "," +
str(self.array_ram_hi[0]) + "," +
str(self.array_ram_hi[1]) + "," +
str(self.array_ram_hi[2]) + "\n")
ram_lo = fuzz.trimf(ram, self.array_ram_lo)
ram_md = fuzz.trimf(ram, self.array_ram_med)
ram_hi = fuzz.trimf(ram, self.array_ram_hi)
ram_antecedent = ctrl.Antecedent(ram, 'ram_antecedent')
self.ram_consequent = ctrl.Consequent(ram, 'ram_consequent')
self.ram_consequent['ram_lo'] = ram_antecedent[
'ram_lo'] = ram_lo
self.ram_consequent['ram_md'] = ram_antecedent[
'ram_md'] = ram_md
self.ram_consequent['ram_hi'] = ram_antecedent[
'ram_hi'] = ram_hi
self.rule1r = ctrl.Rule(
self.memory_antecedent['memory_hi']
& ram_antecedent['ram_lo'], self.ram_consequent['ram_md'])
self.rule2r = ctrl.Rule(
self.memory_antecedent['memory_hi'] &
(ram_antecedent['ram_md'] | ram_antecedent['ram_hi']),
self.ram_consequent['ram_hi'])
self.rule3r = ctrl.Rule(
self.memory_antecedent['memory_lo']
& ram_antecedent['ram_hi'], self.ram_consequent['ram_md'])
self.rule4r = ctrl.Rule(
self.memory_antecedent['memory_lo'] &
(ram_antecedent['ram_md'] | ram_antecedent['ram_lo']),
self.ram_consequent['ram_lo'])
#Update system
self.scalability_ram_ctrl = ctrl.ControlSystem(
[self.rule1r, self.rule2r, self.rule3r, self.rule4r])
#### SERVER RELATED RULES ####
self.rule1s = ctrl.Rule(
self.memory_antecedent['memory_hi']
& ram_antecedent['ram_hi']
& self.servers_antecedent['servers_1'],
self.servers_consequent['servers_2'])
self.rule2s = ctrl.Rule(
(self.memory_antecedent['memory_lo']
| self.memory_antecedent['memory_md'])
& ram_antecedent['ram_lo'] & ~ram_antecedent['ram_hi']
& self.servers_antecedent['servers_2'],
self.servers_consequent['servers_1'])
self.scalability_server_ctrl = ctrl.ControlSystem(
[self.rule1s, self.rule2s])
#Updating State for New Iteration
if new_state != 4:
self.last_action = [[[self.array_ram_lo],
[self.array_ram_med],
[self.array_ram_hi]], new_state]
else:
self.last_action = [[[self.array_ram_lo],
[self.array_ram_med],
[self.array_ram_hi]],
self.last_action[1]]
print("Update action")
print(self.last_action)
