def correctness_category(cor_in=0):
cor_low = fuzz.interp_membership(correctness, c_low, cor_in)
cor_medium = fuzz.interp_membership(correctness, c_medium, cor_in)
cor_high = fuzz.interp_membership(correctness, c_high, cor_in)
return dict(correct_low=cor_low,
correct_medium=cor_medium,
correct_high=cor_high)
def getFuzzyRep(arr):
fuzzRep = ""
fuzztot = 0
x_qual = np.arange(0, 11, 0.1)
qual_lo = fuzz.trimf(x_qual, [0, 0, 0.5])
qual_md = fuzz.trimf(x_qual, [0, 0.5, 1.0])
qual_hi = fuzz.trimf(x_qual, [0.5, 1.0, 1.0])
FuzzVals=["Low","Medium","High"]
i =0
for val in arr:
tmp = FuzzVals[np.argmax([fuzz.interp_membership(x_qual, qual_lo, val),fuzz.interp_membership(x_qual, qual_md, val),fuzz.interp_membership(x_qual, qual_hi, val)])]
if i == 0:
fuzzRep = tmp
else:
fuzzRep = fuzzRep + "," + tmp
if tmp == "Low":
fuzztot += 1
elif tmp == "Medium":
fuzztot += 2
else:
fuzztot += 3
i+=1
return fuzztot
def calculate_target_speed(distance_to_go):
distance, far, medium, close, v_close = set_distance_types()
speed, fast, medium_fast, slow, stop = set_speed_types()
# jeżeli daleko to szybko
distance_level_far = fuzz.interp_membership(distance, far, distance_to_go)
speed_activation_fast = np.fmin(distance_level_far, fast)
# jeżeli średnio daleko to średnio szybko
distance_level_medium = fuzz.interp_membership(distance, medium,
distance_to_go)
speed_activation_medium = np.fmin(distance_level_medium, medium_fast)
# jeżeli blisko to wolno
distance_level_close = fuzz.interp_membership(distance, close,
distance_to_go)
speed_activation_slow = np.fmin(distance_level_close, slow)
# jeżeli bardzo blisko to stop
distance_level_v_close = fuzz.interp_membership(distance, v_close,
distance_to_go)
speed_activation_stop = np.fmin(distance_level_v_close, stop)
# agregacja
aggregated = np.fmax(
speed_activation_fast,
np.fmax(speed_activation_medium,
np.fmax(speed_activation_stop, speed_activation_slow)))
# obliczenie zdyskretyzowanego wyniku
return fuzz.defuzz(speed, aggregated, 'mom')
def patterns_category(pat_in=0):
pat_low = fuzz.interp_membership(patterns, p_low, pat_in)
pat_medium = fuzz.interp_membership(patterns, p_medium, pat_in)
pat_high = fuzz.interp_membership(patterns, p_high, pat_in)
return dict(patterns_low=pat_low,
patterns_medium=pat_medium,
patterns_high=pat_high)
def compute_tip_amout(qual_val, serv_val):
qual_level_poor = fuzz.interp_membership(x_qual, qual_poor, qual_val)
qual_level_amazing = fuzz.interp_membership(x_qual, qual_amazing, qual_val)
serv_level_poor = fuzz.interp_membership(x_serv, serv_poor, serv_val)
serv_level_acceptable = fuzz.interp_membership(x_serv, serv_acceptable,
serv_val)
serv_level_amazing = fuzz.interp_membership(x_serv, serv_amazing, serv_val)
# Rule 1: IF service = poor OR food = poor THEN tip = low
satisfaction_rule1 = np.fmax(qual_level_poor, serv_level_poor)
tip_activation_low = np.fmin(satisfaction_rule1, tip_low)
# Rule 2: IF service = acceptable THEN tip = medium
tip_acitvation_medium = np.fmin(serv_level_acceptable, tip_medium)
# Rule 3: IF service = amazing OR food = amazing THEN tip = high
satisfaction_rule3 = np.fmax(qual_level_amazing, serv_level_amazing)
tip_activation_high = np.fmin(satisfaction_rule3, tip_high)
tip0 = np.zeros_like(x_tip)
#각 규칙의 추론결과 결합
aggregated = np.fmax(tip_activation_low,
np.fmax(tip_acitvation_medium, tip_activation_high))
# 비퍼지화
tip = fuzz.defuzz(x_tip, aggregated, 'centroid')
return tip
def dist_category(dist_in):
dist_cat_far_below = fuzz.interp_membership(dist, far_below, dist_in)
dist_cat_close_below = fuzz.interp_membership(dist, close_below, dist_in)
dist_cat_on_target = fuzz.interp_membership(dist, on_target, dist_in)
dist_cat_close_above = fuzz.interp_membership(dist, close_above, dist_in)
dist_cat_far_above = fuzz.interp_membership(dist, far_above, dist_in)
return dict(fbelow = dist_cat_far_below, cbelow = dist_cat_close_below, target = dist_cat_on_target, cabove = dist_cat_close_above, fabove = dist_cat_far_above)
def compute_cost(_input, _total):
_input_ = []
_total_ = []
for i in xrange(5):
_input_.append(i)
_total_.append(i)
rule = [[0, 0, 1, 2, 3], [0, 1, 1, 2, 3], [1, 1, 2, 3, 3], [2, 2, 3, 4, 4],
[3, 3, 4, 4, 4]]
for i in xrange(5):
_input_[i] = fuzz.interp_membership(input_buffer_occup, inbff_[i],
_input)
_total_[i] = fuzz.interp_membership(total_buffer_occup, tobff_[i],
_total)
n = 0
m = 0
cost = 0
mvalue = 0
for i in _input_:
m = 0
for j in _total_:
if i >= 0 and j >= 0:
cost = cost + min(i, j) * value[rule[n][m]]
mvalue = mvalue + min(i, j)
m = m + 1
n = n + 1
##print cost/mvalue
##print cost
##print mvalue
return float(cost / mvalue)
def single_feature_category(features):
cat_low = fuzzy.interp_membership(features_universe, universe_low,
features)
cat_medium = fuzzy.interp_membership(features_universe, universe_medium,
features)
cat_high = fuzzy.interp_membership(features_universe, universe_high,
features)
return dict(low=cat_low, medium=cat_medium, high=cat_high)
async def run(self):
msgLocal = await self.receive(timeout=10) # wait for a message for 10 seconds
msgVisitante = await self.receive(timeout=10) # wait for a message for 10 seconds
if msgLocal and msgVisitante:
print(Fore.GREEN+'Mensajes recibidos de los agentes recolectores'+Fore.RESET)
else:
raise TimeoutError('Mensaje perdido o no recibido')
# Parseamos el string del body del mensaje otra vez a un diccionario
equipoLocal = json.loads(msgLocal.body)
equipoVisitante = json.loads(msgVisitante.body)
# Metemos los datos en el controlador
self.quiniela.input['Clasificacion_Local'] = equipoLocal['clasificacion']
self.quiniela.input['Clasificacion_Visitante'] = equipoVisitante['clasificacion']
self.quiniela.input['Presupuesto_Local'] = (equipoLocal['presupuesto'] / 1000000)
self.quiniela.input['Presupuesto_Visitante'] = (equipoVisitante['presupuesto'] / 1000000)
self.quiniela.input['RachaG_Local'] = equipoLocal['rachas']['ganando']
self.quiniela.input['RachaG_Visitante'] = equipoVisitante['rachas']['ganando']
self.quiniela.input['RachaE_Local'] = equipoLocal['rachas']['empatando']
self.quiniela.input['RachaE_Visitante'] = equipoVisitante['rachas']['empatando']
self.quiniela.input['RachaP_Local'] = equipoLocal['rachas']['perdiendo']
self.quiniela.input['RachaP_Visitante'] = equipoVisitante['rachas']['perdiendo']
self.quiniela.input['RachaNG_Local'] = equipoLocal['rachas']['sin_ganar']
self.quiniela.input['RachaNG_Visitante'] = equipoVisitante['rachas']['sin_ganar']
self.quiniela.input['RachaNP_Local'] = equipoLocal['rachas']['sin_perder']
self.quiniela.input['RachaNP_Visitante'] = equipoVisitante['rachas']['sin_perder']
# Computamos para obtener las pertenecias
self.quiniela.compute()
range_result = np.arange(1, 9, 1)
val = self.quiniela.output['Result']
variable = reglas.consequent()['1']
pertenencia_1 = fuzz.interp_membership(range_result, variable.mf, val)
val = self.quiniela.output['Result']
variable = reglas.consequent()['X']
pertenencia_x = fuzz.interp_membership(range_result, variable.mf, val)
val = self.quiniela.output['Result']
variable = reglas.consequent()['2']
pertenencia_2 = fuzz.interp_membership(range_result, variable.mf, val)
# Una vez obtenidasd las pertenencias de cada resultado, las ordenamos
pertenencias = {'1': pertenencia_1,
'X': pertenencia_x,
'2': pertenencia_2}
pertenencias_ord = sorted(pertenencias.items(), key=operator.itemgetter(1), reverse=True)
# Printeamos el resultado
print(Back.YELLOW+Style.BRIGHT+Fore.BLACK+'Etiqueta resultado:'+Back.RESET+Fore.RESET,
Fore.GREEN+f' {pertenencias_ord[0][0]}'+Fore.RESET+Style.RESET_ALL)
print(Back.YELLOW+Style.BRIGHT+Fore.BLACK+'Máximo grado de pertencia:'+Back.RESET+Fore.RESET,
Fore.GREEN+f' {pertenencias_ord[0][1]}'+Fore.RESET+Style.RESET_ALL)
# Paramos el agente
await self.agent.stop()
def reputhation_category(rep_in=0):
a_r_low = fuzz.interp_membership(author_reputation, r_low, rep_in)
a_r_medium = fuzz.interp_membership(author_reputation, r_medium,
rep_in)
a_r_high = fuzz.interp_membership(author_reputation, r_high,
rep_in)
return dict(rep_low=a_r_low,
rep_medium=a_r_medium,
rep_high=a_r_high)
def service_category(service_in=4):
service_cat_poor = fuzz.interp_membership(
service, service_poor, service_in) # Depends from Step 1
service_cat_good = fuzz.interp_membership(service, service_poor,
service_in)
service_cat_excellent = fuzz.interp_membership(service, service_excellent,
service_in)
return dict(poor=service_cat_poor,
good=service_cat_good,
excellent=service_cat_poor)
def convert_last_time_peed(last_time_peed_in_hours):
now = fuzz.interp_membership(last_time_peed_range,
last_time_peed_now_function,
last_time_peed_in_hours)
couple_of_hours = fuzz.interp_membership(
last_time_peed_range, last_time_peed_couple_of_hours_function,
last_time_peed_in_hours)
many_hours = fuzz.interp_membership(
last_time_peed_range, last_time_peed_many_hours_function,
last_time_peed_in_hours)
return [now, couple_of_hours, many_hours]
def temperature_category(temperature_in=18):
temperature_cat_cold = fuzz.interp_membership(temperature,
temperature_cold,
temperature_in)
temperature_cat_warm = fuzz.interp_membership(temperature,
temperature_warm,
temperature_in)
temperature_cat_hot = fuzz.interp_membership(temperature, temperature_hot,
temperature_in)
return dict(cold=temperature_cat_cold,
warm=temperature_cat_warm,
hot=temperature_cat_hot)
def rule_actividad(value, graficar=False):
# recibe los datos para poder seguir el proceso difuso para encontrar la pertenencia
# retorna el valor al que pertenece en la clase segun la hora
mf_actividad = generar_actividad(False)
mf_calorico = generar_calorico(False)
# se usa para encontrar los grados de pertenencia del valor, borrificacion
actividad_nivel_rest = fuzz.interp_membership(mf_actividad['intensity'],
mf_actividad['rest'], value)
actividad_nivel_std = fuzz.interp_membership(mf_actividad['intensity'],
mf_actividad['active'], value)
actividad_nivel_work = fuzz.interp_membership(mf_actividad['intensity'],
mf_actividad['workout'],
value)
# regla: si rest -> low
rest_activation = np.fmin(actividad_nivel_rest, mf_calorico['low'])
# regla: si active -> std
active_activation = np.fmin(actividad_nivel_std, mf_calorico['standard'])
# regla: si workout -> high
workout_activation = np.fmin(actividad_nivel_work, mf_calorico['high'])
# deborrificacion
agregado = np.fmax(rest_activation,
np.fmax(active_activation, workout_activation))
caloric = fuzz.defuzz(mf_calorico['caloric'], agregado, 'centroid')
# # graficar
# if graficar:
# select_caloric = fuzz.interp_membership(mf_calorico['caloric'], agregado, caloric)
# caloric0 = np.zeros_like(mf_calorico['caloric'])
# fig, ax0 = plt.subplots(figsize=(8, 3))
#
# ax0.plot(mf_calorico['caloric'], mf_calorico['low'], 'b', linewidth=0.5, linestyle='--', label='Low')
# ax0.plot(mf_calorico['caloric'], mf_calorico['standard'], 'g', linewidth=0.5, linestyle='--', label='Standard')
# ax0.plot(mf_calorico['caloric'], mf_calorico['high'], 'r', linewidth=0.5, linestyle='--', label='High')
# ax0.fill_between(mf_calorico['caloric'], caloric0, agregado, facecolor='Orange', alpha=0.7)
# ax0.plot([caloric, caloric], [0, select_caloric], 'k', linewidth=1.5, alpha=0.9)
# ax0.set_title('Dish Classification and Result (line)')
# ax0.legend()
# # Turn off top/right axes
# for ax in (ax0,):
# ax.spines['top'].set_visible(False)
# ax.spines['right'].set_visible(False)
# ax.get_xaxis().tick_bottom()
# ax.get_yaxis().tick_left()
#
# plt.tight_layout()
# #fig.savefig('graphs/result_calorico.png', bbox_inches='tight')
#
return caloric, "caloric"
def apply_rule_to_get_activation_values(temp, visualizing=False):
temp_level_cold = fuzz.interp_membership(x_temp, temp_cold, temp)
temp_level_pleasant = fuzz.interp_membership(x_temp, temp_pleasant, temp)
temp_level_hot = fuzz.interp_membership(x_temp, temp_hot, temp)
# Now we apply this by clipping the top off the corresponding output
# membership function with `np.fmin`
power_activation_low = np.fmin(temp_level_cold, power_low)
power_activation_mid = np.fmin(temp_level_pleasant, power_mid)
power_activation_high = np.fmin(temp_level_hot, power_high)
# Visualize this
if visualizing:
fig, ax0 = plt.subplots(figsize=(8, 3))
ax0.fill_between(x_power,
power0,
power_activation_low,
facecolor='b',
alpha=0.7)
ax0.plot(
x_power,
power_low,
'b',
linewidth=0.5,
linestyle='--',
)
ax0.fill_between(x_power,
power0,
power_activation_mid,
facecolor='g',
alpha=0.7)
ax0.plot(x_power, power_mid, 'g', linewidth=0.5, linestyle='--')
ax0.fill_between(x_power,
power0,
power_activation_high,
facecolor='r',
alpha=0.7)
ax0.plot(x_power, power_high, 'r', linewidth=0.5, linestyle='--')
ax0.set_title('Output membership activity')
# Turn off top/right axes
for ax in (ax0, ):
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.get_xaxis().tick_bottom()
ax.get_yaxis().tick_left()
plt.tight_layout()
plt.show()
return power_activation_low, power_activation_mid, power_activation_high
def rule_hora(hour, graficar=False):
# recibe los datos para poder seguir el proceso difuso para encontrar la pertenencia
# retorna el valor al que pertenece en la clase segun la hora
mf_hora = generar_hora(False)
mf_clase = generar_clase(False)
# se usa para encontrar los grados de pertenencia del valor, borrificacion
hora_nivel_morn = fuzz.interp_membership(mf_hora['horario'],
mf_hora['morning'], hour)
hora_nivel_aft = fuzz.interp_membership(mf_hora['horario'],
mf_hora['afternoon'], hour)
hora_nivel_eve = fuzz.interp_membership(mf_hora['horario'],
mf_hora['evening'], hour)
# regla: si manana -> desayuno
breakfast_activation = np.fmin(hora_nivel_morn, mf_clase['breakfast'])
# regla: si medio dia -> almuerzo
lunch_activation = np.fmin(hora_nivel_aft, mf_clase['lunch'])
# regla: si medio dia -> almuerzo
dinner_activation = np.fmin(hora_nivel_eve, mf_clase['dinner'])
# deborrificacion
agregado = np.fmax(breakfast_activation,
np.fmax(lunch_activation, dinner_activation))
clase = fuzz.defuzz(mf_clase['clase'], agregado, 'centroid')
# graficar
# if graficar:
# select_clase = fuzz.interp_membership(mf_clase['clase'], agregado, clase)
# clase0 = np.zeros_like(mf_clase['clase'])
# fig, ax0 = plt.subplots(figsize=(8, 3))
#
# ax0.plot(mf_clase['clase'], mf_clase['breakfast'], 'b', linewidth=0.5, linestyle='--', label='Breakfast')
# ax0.plot(mf_clase['clase'], mf_clase['lunch'], 'g', linewidth=0.5, linestyle='--', label='Lunch')
# ax0.plot(mf_clase['clase'], mf_clase['dinner'], 'r', linewidth=0.5, linestyle='--', label='Dinner')
# ax0.fill_between(mf_clase['clase'], clase0, agregado, facecolor='Orange', alpha=0.7)
# ax0.plot([clase, clase], [0, select_clase], 'k', linewidth=1.5, alpha=0.9)
# ax0.set_title('Dish Classification and Result (line)')
# ax0.legend()
# # Turn off top/right axes
# for ax in (ax0,):
# ax.spines['top'].set_visible(False)
# ax.spines['right'].set_visible(False)
# ax.get_xaxis().tick_bottom()
# ax.get_yaxis().tick_left()
#
# plt.tight_layout()
# #fig.savefig('graphs/result_clase.png', bbox_inches='tight')
#
return clase, "clase"
def interpret_data(agent):
ball_angle = angle2D(agent.ball, agent.me)
ball_distance = distance2D(agent.ball, agent.me) # Get distance to ball
rule = []
throttle_activation = []
steer_activation = []
for i in range(0, agent.num_rules):
if (agent.labels[i * 3 + 2].find('c') > 0):
rule_a1 = fuzz.interp_membership(agent.universes[i * 3],
agent.ruleset[i * 3],
ball_distance)
rule_a2 = fuzz.interp_membership(agent.universes[i * 3 + 1],
agent.ruleset[i * 3 + 1],
ball_angle)
active_rule = np.fmax(rule_a1, rule_a2)
rule_support = np.fmin(active_rule, agent.ruleset[i * 3 + 2])
throttle_activation.append(rule_support)
else:
rule_a1 = fuzz.interp_membership(agent.universes[i * 3],
agent.ruleset[i * 3],
ball_distance)
rule_a2 = fuzz.interp_membership(agent.universes[i * 3 + 1],
agent.ruleset[i * 3 + 1],
ball_angle)
active_rule = np.fmax(rule_a1, rule_a2)
rule_support = np.fmin(active_rule, agent.ruleset[i * 3 + 2])
steer_activation.append(rule_support)
agg_throttle = 0
agg_steer = 0
for i in range(0, len(throttle_activation) - 1):
agg_throttle = np.fmax(throttle_activation[i],
throttle_activation[i + 1])
for i in range(0, len(steer_activation) - 1):
agg_steer = np.fmax(steer_activation[i], steer_activation[i + 1])
throttle = 0
steer = 0
if (any(agg_throttle) > 0):
throttle = fuzz.defuzz(agent.fuzzy.throttle, agg_throttle, 'centroid')
if (any(agg_steer) > 0):
steer = fuzz.defuzz(agent.fuzzy.turn, agg_steer, 'centroid')
#print(steer)
return [throttle, steer]
def convert_crying_intensity(crying_intensity):
none = fuzz.interp_membership(crying_intensity_range,
crying_intensity_none_function,
crying_intensity)
slight = fuzz.interp_membership(crying_intensity_range,
crying_intensity_slight_function,
crying_intensity)
medium = fuzz.interp_membership(crying_intensity_range,
crying_intensity_medium_function,
crying_intensity)
high = fuzz.interp_membership(crying_intensity_range,
crying_intensity_high_function,
crying_intensity)
return [none, slight, medium, high]
def identify_pose():
global arm_pos_cartesian
arm_pos_cartesian = []
global is_identify
global right_neural_net, right_fuzzy_sets, right_fuzzy_sets_range
global left_neural_net, left_fuzzy_sets, left_fuzzy_sets_range
is_identify = True
while len(arm_pos_cartesian) < 5:
is_identify = True
is_identify = False
# taking average of all the poses...
scanned = np.array(arm_pos_cartesian)
pose_left = [
scanned[:, 0, 0].mean(), scanned[:, 0, 1].mean(),
scanned[:, 1, 0].mean(), scanned[:, 1, 1].mean()
]
pose_right = [
scanned[:, 2, 0].mean(), scanned[:, 2, 1].mean(),
scanned[:, 3, 0].mean(), scanned[:, 3, 1].mean()
]
left_rule_data = []
for k, dim in enumerate(pose_left):
fuzzy_rules = left_fuzzy_sets[k]
for rule in fuzzy_rules:
if (dim > min(left_fuzzy_sets_range[k])
and dim < max(left_fuzzy_sets_range[k])):
temp = fuzz.interp_membership(left_fuzzy_sets_range[k], rule,
dim)
else:
temp = 0
left_rule_data.append(temp)
left_detected_pose = np.argmax(left_neural_net.activate(left_rule_data))
right_rule_data = []
for k, dim in enumerate(pose_right):
fuzzy_rules = right_fuzzy_sets[k]
for rule in fuzzy_rules:
if (dim > min(right_fuzzy_sets_range[k])
and dim < max(right_fuzzy_sets_range[k])):
temp = fuzz.interp_membership(right_fuzzy_sets_range[k], rule,
dim)
else:
temp = 0
right_rule_data.append(temp)
right_detected_pose = np.argmax(right_neural_net.activate(right_rule_data))
return [right_detected_pose, left_detected_pose]
def rule_actividad(value, graficar=False):
# recibe los datos para poder seguir el proceso difuso para encontrar la pertenencia
# retorna el valor al que pertenece en la clase segun la hora
mf_actividad = generar_actividad(False)
mf_calorico = generar_calorico(False)
# se usa para encontrar los grados de pertenencia del valor, borrificacion
actividad_nivel_rest = fuzz.interp_membership(mf_actividad['intensity'], mf_actividad['rest'], value)
actividad_nivel_std = fuzz.interp_membership(mf_actividad['intensity'], mf_actividad['active'], value)
actividad_nivel_work = fuzz.interp_membership(mf_actividad['intensity'], mf_actividad['workout'], value)
# regla: si rest -> low
rest_activation = np.fmin(actividad_nivel_rest, mf_calorico['low'])
# regla: si active -> std
active_activation = np.fmin(actividad_nivel_std, mf_calorico['standard'])
# regla: si workout -> high
workout_activation = np.fmin(actividad_nivel_work, mf_calorico['high'])
# deborrificacion
agregado = np.fmax(rest_activation, np.fmax(active_activation, workout_activation))
caloric = fuzz.defuzz(mf_calorico['caloric'], agregado, 'centroid')
# # graficar
# if graficar:
# select_caloric = fuzz.interp_membership(mf_calorico['caloric'], agregado, caloric)
# caloric0 = np.zeros_like(mf_calorico['caloric'])
# fig, ax0 = plt.subplots(figsize=(8, 3))
#
# ax0.plot(mf_calorico['caloric'], mf_calorico['low'], 'b', linewidth=0.5, linestyle='--', label='Low')
# ax0.plot(mf_calorico['caloric'], mf_calorico['standard'], 'g', linewidth=0.5, linestyle='--', label='Standard')
# ax0.plot(mf_calorico['caloric'], mf_calorico['high'], 'r', linewidth=0.5, linestyle='--', label='High')
# ax0.fill_between(mf_calorico['caloric'], caloric0, agregado, facecolor='Orange', alpha=0.7)
# ax0.plot([caloric, caloric], [0, select_caloric], 'k', linewidth=1.5, alpha=0.9)
# ax0.set_title('Dish Classification and Result (line)')
# ax0.legend()
# # Turn off top/right axes
# for ax in (ax0,):
# ax.spines['top'].set_visible(False)
# ax.spines['right'].set_visible(False)
# ax.get_xaxis().tick_bottom()
# ax.get_yaxis().tick_left()
#
# plt.tight_layout()
# #fig.savefig('graphs/result_calorico.png', bbox_inches='tight')
#
return caloric, "caloric"
def compute_activations(self, X):
if not hasattr(self, 'best_fuzzy_model'):
self.best_fuzzy_model = joblib.load(
os.path.join(self.path_fuzzy, self.file_fuzzy))
self.rules = self.best_fuzzy_model['rules']
activations = pd.DataFrame(
index=X.index, columns=[i for i in sorted(self.rules.keys())])
var_del = []
for rule in sorted(self.rules.keys()):
act = []
for mf in self.rules[rule]:
if mf['var_name'] not in X.columns:
var_names = [c for c in X.columns if mf['var_name'] in c]
X[mf['var_name']] = X[var_names].mean(axis=1)
var_del.append(mf['var_name'])
act.append(
fuzz.interp_membership(mf['universe'], mf['func'],
X[mf['var_name']]))
if not 'p' in mf.keys():
mf['p'] = 2
activations[rule] = np.power(np.prod(np.array(act), axis=0),
1 / mf['p'])
if len(var_del) > 0:
X = X.drop(columns=var_del)
return activations
def run(self):
""" inputs[0] = ERROR AXIS ., so stores all possible error values
inputs[1] = DEL_ERROR AXIS ., ,,
inputs[2] = CONTROL_OUTPUT AXIS ., ,,
ERROR DEL_ERROR CONTROL_OUTPUT m_value for crisp e and delta_e values
b[0][0] -ve Medium || b[1][0] -ve Medium || b[2][0] -ve Medium .. f[0] | f_d[0]
b[0][1] -ve small || b[1][1] -ve small || b[2][1] -ve small .. f[1] | f_d[1]
b[0][2] zero || b[1][2] zero || b[2][2] zero .. f[2] | f_d[2]
b[0][3] +ve small || b[1][3] +ve small || b[2][3] +ve small .. f[3] | f_d[3]
b[0][4] +ve Medium || b[1][4] +ve Medium || b[2][4] +_ve Medium .. f[4] | f_d[4]
f_mat is fuzzy fuzzy_matrix
"""
inputs = [ np.arange(var[0], var[1]+1, 1) for var in self.var_ranges] #step size = 1, third dimension of b matrix. As of now, an assumption.
b = []
output = [0,0,0,0,0]
out_final = []
for i in range(3) :
b.append( [membership_f(self.mu[i], inputs[i], a) for a in self.d_mu[i] ])
# To visualize the membership func. call .. [ visualize_mf(b,inputs) ]
f ,f_d = error_fuzzify(inputs, b, self.error, self.delta_e)
f_mat = fuzzy_matrix(f,f_d)
output = rule_base(b, f_mat, output)
print 'output : ', output
aggregated = np.fmax(output[0], np.fmax(output[1],np.fmax(output[2], np.fmax(output[3], output[4]))))
out_final = fuzz.defuzz(inputs[2], aggregated, 'centroid')
out_activation = fuzz.interp_membership(inputs[2], aggregated, out_final) # for plot
visualize.visualize_mf(b,inputs,output, out_final, out_activation, aggregated)
visualize.visualize_output(b, inputs, out_final, out_activation, aggregated)
plt.show()
def dnp_category(self, dnp_in=0):
dnp_cat_tooclose = fuzz.interp_membership(self.dnp, self.dnp_tooclose,
dnp_in)
dnp_cat_close = fuzz.interp_membership(self.dnp, self.dnp_close,
dnp_in)
dnp_cat_medium = fuzz.interp_membership(self.dnp, self.dnp_medium,
dnp_in)
dnp_cat_far = fuzz.interp_membership(self.dnp, self.dnp_far, dnp_in)
dnp_cat_toofar = fuzz.interp_membership(self.dnp, self.dnp_toofar,
dnp_in)
return dict(tooclose=dnp_cat_tooclose,
close=dnp_cat_close,
medium=dnp_cat_medium,
far=dnp_cat_far,
toofar=dnp_cat_toofar)
def visualize_output(b, inputs, output, out_final, aggregated):
# Visualize this
out_activation = fuzz.interp_membership(inputs[2], aggregated, out_final) # for plot
fig, (ax3, ax4) = plt.subplots(nrows=2, figsize=(8, 5))
output0 = np.zeros_like(inputs[2])
ax3.fill_between(inputs[2], output0, output[0], facecolor='g', alpha=0.7)
ax3.plot(inputs[2], b[2][0], 'g', linewidth=0.5, linestyle='--' )
ax3.fill_between(inputs[2], output0, output[1], facecolor='r', alpha=0.7)
ax3.plot(inputs[2], b[2][1], 'r', linewidth=0.5, linestyle='--')
ax3.fill_between(inputs[2], output0, output[2], facecolor='k', alpha=0.7)
ax3.plot(inputs[2], b[2][2], 'c', linewidth=0.5, linestyle='--' )
ax3.fill_between(inputs[2], output0, output[3], facecolor='m', alpha=0.7)
ax3.plot(inputs[2], b[2][3], 'm', linewidth=0.5, linestyle='--')
ax3.fill_between(inputs[2], output0, output[4], facecolor='c', alpha=0.7)
ax3.plot(inputs[2], b[2][4], 'y', linewidth=0.5, linestyle='--')
ax3.set_title('Output membership activity')
ax4.plot(inputs[2], b[2][0], 'g', linewidth=0.5, linestyle='--', )
ax4.plot(inputs[2], b[2][1], 'r', linewidth=0.5, linestyle='--', )
ax4.plot(inputs[2], b[2][2], 'c', linewidth=0.5, linestyle='--', )
ax4.plot(inputs[2], b[2][3], 'm', linewidth=0.5, linestyle='--', )
ax4.plot(inputs[2], b[2][4], 'y', linewidth=0.5, linestyle='--', )
ax4.fill_between(inputs[2], output0, aggregated, facecolor='g', alpha=0.7)
ax4.plot([out_final, out_final], [0, out_activation], 'k', linewidth=1.5, alpha=0.9)
ax4.set_title('Aggregated membership and result (line)')
for ax in (ax3, ax4):
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.get_xaxis().tick_bottom()
ax.get_yaxis().tick_left()
plt.tight_layout()
plt.show()
def fuzzyfication_NN(self, x):
#фазификация для нейросети
#когда на входе не слово, а четкое значение
for s in self.comands:
self.fuzzy_q[s] = fuzz.interp_membership(self.terms["U"],
self.terms[s], x)
return True
def visualize_result(X, mem3, risk0, aggregated, result):
activation = fuzz.interp_membership(X[2], aggregated, result)
fig, ax0 = plt.subplots(figsize=(8, 3))
ax0.plot(
X[2],
mem3[0],
'b',
linewidth=0.5,
linestyle='--',
)
ax0.plot(X[2], mem3[1], 'g', linewidth=0.5, linestyle='--')
ax0.plot(X[2], mem3[2], 'r', linewidth=0.5, linestyle='--')
ax0.fill_between(X[2], risk0, aggregated, facecolor='Orange', alpha=0.7)
ax0.plot([result, result], [0, activation], 'k', linewidth=1.5, alpha=0.9)
ax0.set_title('Aggregated membership and result (line)')
for ax in (ax0, ):
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.get_xaxis().tick_bottom()
ax.get_yaxis().tick_left()
plt.tight_layout()
plt.show()
def fuzzyfication(self, word):
#фазификация
for s in self.comands:
self.fuzzy_q[s] = fuzz.interp_membership(self.terms["U"],
self.terms[s],
self.key_words[word])
return True
def desfuzzy(universe, fuzzy_array):
# Defuzzify this membership function five ways
defuzz_centroid = fuzz.defuzz(universe, fuzzy_array,
'centroid') # Same as skfuzzy.centroid
defuzz_bisector = fuzz.defuzz(universe, fuzzy_array, 'bisector')
# Collect info for vertical lines
labels = [
'centroid', 'bisector', 'mean of maximum', 'min of maximum',
'max of maximum'
]
xvals = [defuzz_centroid, defuzz_bisector]
colors = ['r', 'b']
ymax = [fuzz.interp_membership(universe, fuzzy_array, i) for i in xvals]
# Display and compare defuzzification results against membership function
plt.figure(figsize=(8, 5))
plt.plot(universe, fuzzy_array, 'k')
for xv, y, label, color in zip(xvals, ymax, labels, colors):
plt.vlines(xv, 0, y, label=label, color=color)
plt.ylabel('Fuzzy membership')
plt.xlabel('Universe variable (arb)')
plt.ylim(-0.1, 1.1)
plt.legend(loc=2)
plt.show()
def rule_hora(hour, graficar=False):
# recibe los datos para poder seguir el proceso difuso para encontrar la pertenencia
# retorna el valor al que pertenece en la clase segun la hora
mf_hora = generar_hora(False)
mf_clase = generar_clase(False)
# se usa para encontrar los grados de pertenencia del valor, borrificacion
hora_nivel_morn = fuzz.interp_membership(mf_hora['horario'], mf_hora['morning'], hour)
hora_nivel_aft = fuzz.interp_membership(mf_hora['horario'], mf_hora['afternoon'], hour)
hora_nivel_eve = fuzz.interp_membership(mf_hora['horario'], mf_hora['evening'], hour)
# regla: si manana -> desayuno
breakfast_activation = np.fmin(hora_nivel_morn, mf_clase['breakfast'])
# regla: si medio dia -> almuerzo
lunch_activation = np.fmin(hora_nivel_aft, mf_clase['lunch'])
# regla: si medio dia -> almuerzo
dinner_activation = np.fmin(hora_nivel_eve, mf_clase['dinner'])
# deborrificacion
agregado = np.fmax(breakfast_activation, np.fmax(lunch_activation, dinner_activation))
clase = fuzz.defuzz(mf_clase['clase'], agregado, 'centroid')
# graficar
# if graficar:
# select_clase = fuzz.interp_membership(mf_clase['clase'], agregado, clase)
# clase0 = np.zeros_like(mf_clase['clase'])
# fig, ax0 = plt.subplots(figsize=(8, 3))
#
# ax0.plot(mf_clase['clase'], mf_clase['breakfast'], 'b', linewidth=0.5, linestyle='--', label='Breakfast')
# ax0.plot(mf_clase['clase'], mf_clase['lunch'], 'g', linewidth=0.5, linestyle='--', label='Lunch')
# ax0.plot(mf_clase['clase'], mf_clase['dinner'], 'r', linewidth=0.5, linestyle='--', label='Dinner')
# ax0.fill_between(mf_clase['clase'], clase0, agregado, facecolor='Orange', alpha=0.7)
# ax0.plot([clase, clase], [0, select_clase], 'k', linewidth=1.5, alpha=0.9)
# ax0.set_title('Dish Classification and Result (line)')
# ax0.legend()
# # Turn off top/right axes
# for ax in (ax0,):
# ax.spines['top'].set_visible(False)
# ax.spines['right'].set_visible(False)
# ax.get_xaxis().tick_bottom()
# ax.get_yaxis().tick_left()
#
# plt.tight_layout()
# #fig.savefig('graphs/result_clase.png', bbox_inches='tight')
#
return clase, "clase"
def find_memberships(self):
# Check we have some adjectives
if len(self.var.terms.keys()) == 0:
raise ValueError("Set term membership function(s) first")
'''
First we have to upsample the universe of self.var in order to add the
key points of the membership function based on the activation level
for this consequent, using the interp_universe function, which
interpolates the `xx` values in the universe such that its membership
function value is the activation level.
'''
add_universe = set()
for label, term in self.var.terms.items():
cut = term.membership_value[self.sim]
if cut is None:
continue # No membership defined for this adjective
add_xx = interp_universe(self.var.universe, term.mf, cut)
add_universe.update(add_xx)
# We are only interested in points not in self.var.universe
add_universe = add_universe - set(self.var.universe)
# We want to sort the universe values and keep related their indices
# to access to their mf values
upsampled_universe = (list(
zip(
self.var.universe.tolist() + list(add_universe),
list(range(self.var.universe.size)) +
[None] * len(add_universe))))
upsampled_universe.sort(key=lambda element: element[0])
upsampled_mf_indices = [element[1] for element in upsampled_universe]
upsampled_universe = np.array(
[element[0] for element in upsampled_universe])
# Initilize membership
output_mf = np.zeros_like(upsampled_universe, dtype=np.float64)
# Build output membership function
term_mfs = {}
for label, term in self.var.terms.items():
cut = term.membership_value[self.sim]
if cut is None:
continue # No membership defined for this adjective
upsampled_mf = []
for i in range(len(upsampled_mf_indices)):
if upsampled_mf_indices[i] is not None:
upsampled_mf.append(term.mf[upsampled_mf_indices[i]])
else:
upsampled_mf.append(
interp_membership(self.var.universe, term.mf,
upsampled_universe[i]))
term_mfs[label] = np.minimum(cut, upsampled_mf)
np.maximum(output_mf, term_mfs[label], output_mf)
return upsampled_universe, output_mf, term_mfs
def compute_vague_range(self, allDocs, fieldName, weight, minValue,
maxValue):
allValues = []
for doc in allDocs['hits']['hits']:
if (doc['_source'][fieldName]):
allValues.append(float(doc['_source'][fieldName]))
allValues = np.sort((np.array(allValues)))
if maxValue is None:
maxValue = allValues[-1]
if minValue is None:
minValue = allValues[0]
lowerSupport = float(minValue) - ((float(minValue) - allValues[0]) / 2)
upperSupport = float(maxValue) + (
(allValues[-1] - float(maxValue)) / 2)
if minValue == 0:
lowerSupport = 0
trapmf = fuzz.trapmf(
allValues,
[lowerSupport,
float(minValue),
float(maxValue), upperSupport])
body = {
"query": {
"range": {
fieldName: {
"gte":
lowerSupport, # elastic search gte operator = greater than or equals
"lte":
upperSupport # elastic search lte operator = less than or equals
}
}
}
}
# size in range queries should be as many as possible, because when the difference upperSupport and lowerSupport is big, we can lose some products
# (whose price actually between the minPrice and maxPrice) because we just want to get the first 100 element
res = self.es.search(index="amazon", body=body, size=10000)
result = []
for hit in res['hits']['hits']:
result.append([
hit['_source']['asin'], # hit['_source']['price'],
weight * fuzz.interp_membership(
allValues, trapmf, float(hit['_source'][fieldName]))
])
result = np.array(result, dtype=object)
result = result[np.argsort(-result[:, 1])]
# just return the first 100 element(i think 1000 is just too many, but we can change it later)
#result = result[:100]
result = list(map(tuple, result))
# print(result)
return result
def calculate(self, p, i, d):
""" Calculates the fuzzy output gain """
# Calculate membership value for each function
if self.p_range is not None:
p_interp = {
k: interp_membership(self.p_range, mf, p)
for k, mf in self.p_mf.iteritems()
}
print max(p_interp.iteritems(), key=operator.itemgetter(1))[0]
else:
p_interp = {}
if self.i_range is not None:
i_interp = {
k: interp_membership(self.i_range, mf, i)
for k, mf in self.i_mf.iteritems()
}
print max(i_interp.iteritems(), key=operator.itemgetter(1))[0]
else:
i_interp = {}
if self.d_range is not None:
d_interp = {
k: interp_membership(self.d_range, mf, d)
for k, mf in self.d_mf.iteritems()
}
print max(d_interp.iteritems(), key=operator.itemgetter(1))[0]
else:
d_interp = {}
# Merge rule-bases
dicts = [p_interp, i_interp, d_interp]
super_dict = {}
for k in set(k for d in dicts for k in d):
super_dict[k] = [d[k] for d in dicts if k in d]
# Generated inferences by rule implications
aggregate_membership = np.zeros(len(self.c_range))
for a, b, c in self.c_rules:
try:
impl = np.fmin(super_dict[a], super_dict[b]) * self.c_mf[c]
aggregate_membership = np.fmax(impl, aggregate_membership)
except:
pass
c = defuzz(self.c_range, aggregate_membership, 'centroid')
return c # this is the resulting "value" of the current state
def fuzz(self, value):
"""Propagate crisp value down to adjectives by calculating membership"""
if len(self.var.terms) == 0:
raise ValueError("Set Term membership function(s) first")
for label, term in self.var.terms.items():
term.membership_value[self.sim] = \
interp_membership(self.var.universe, term.mf, value)
def get_move_and_degree(optimal, universe):
fold_val = fuzz.interp_membership(universe,
fuzz.trimf(universe, [0, 0, 0.5]),
optimal)
call_val = fuzz.interp_membership(universe,
fuzz.trimf(universe, [0, 0.5, 1]),
optimal)
raise_val = fuzz.interp_membership(universe,
fuzz.trimf(universe, [0.5, 1, 1]),
optimal)
actions = [(fold_val, 'fold'), (call_val, 'call'), (raise_val, 'raise')]
# The result is the action related to the highest similarity
result = max(actions, key=itemgetter(0))
return result
def relevance(distance: float):
"""
Given the distance, it returns a degree of pertinence. Necessary to apply the fuzzy technique,
in adjusting the weights. For distance 0, returns the degree of relevance 1
"""
universe = np.arange(0, 100, 1)
return fuzz.interp_membership(universe, fuzz.gaussmf(universe, 0.0, 5),
distance)
def find_memberships(self):
# Check we have some adjectives
if len(self.var.terms.keys()) == 0:
raise ValueError("Set term membership function(s) first")
'''
First we have to upsample the universe of self.var in order to add the
key points of the membership function based on the activation level
for this consequent, using the interp_universe function, which
interpolates the `xx` values in the universe such that its membership
function value is the activation level.
'''
add_universe = set()
for label, term in self.var.terms.items():
cut = term.membership_value[self.sim]
if cut is None:
continue # No membership defined for this adjective
add_xx = interp_universe(self.var.universe, term.mf, cut)
add_universe.update(add_xx)
# We are only interested in points not in self.var.universe
add_universe = add_universe - set(self.var.universe)
# We want to sort the universe values and keep related their indices
# to access to their mf values
upsampled_universe = (
list(zip(self.var.universe.tolist() + list(add_universe),
list(range(self.var.universe.size)) + [None] * len(add_universe))))
upsampled_universe.sort(key=lambda element: element[0])
upsampled_mf_indices = [element[1] for element in upsampled_universe]
upsampled_universe = np.array([
element[0] for element in upsampled_universe])
# Initilize membership
output_mf = np.zeros_like(upsampled_universe, dtype=np.float64)
# Build output membership function
term_mfs = {}
for label, term in self.var.terms.items():
cut = term.membership_value[self.sim]
if cut is None:
continue # No membership defined for this adjective
upsampled_mf = []
for i in range(len(upsampled_mf_indices)):
if upsampled_mf_indices[i] is not None:
upsampled_mf.append(term.mf[upsampled_mf_indices[i]])
else:
upsampled_mf.append(
interp_membership(self.var.universe, term.mf,
upsampled_universe[i]))
term_mfs[label] = np.minimum(cut, upsampled_mf)
np.maximum(output_mf, term_mfs[label], output_mf)
return upsampled_universe, output_mf, term_mfs
def throttle_command(speed_read):
# Universe of discourse
speed = np.arange(60,150,.1)
throttle_value = np.arange(0,1,0.01)
# Input membership functions
too_slow = fuzz.trapmf(speed,[60,60,80,85])
slow = fuzz.trimf(speed,[83,90,97])
cruise = fuzz.trimf(speed,[95,100,105])
fast = fuzz.trimf(speed,[103,110,117])
too_fast = fuzz.trapmf(speed,[115,120,150,150])
# Output membership functions
very_low = fuzz.trimf(throttle_value,[0,0,0.15])
low = fuzz.trimf(throttle_value,[0.1,0.25,0.4])
medium = fuzz.trimf(throttle_value,[0.35,0.5,0.65])
high = fuzz.trimf(throttle_value,[0.6,0.75,0.9])
very_high = fuzz.trimf(throttle_value,[0.85,1,1])
# membership values
speed_cat_too_slow = fuzz.interp_membership(speed,too_slow,speed_read)
speed_cat_slow = fuzz.interp_membership(speed,slow,speed_read)
speed_cat_cruise = fuzz.interp_membership(speed,cruise,speed_read)
speed_cat_fast = fuzz.interp_membership(speed,fast,speed_read)
speed_cat_too_fast = fuzz.interp_membership(speed,too_fast,speed_read)
# If part of rules
rule1 = speed_cat_too_slow
rule2 = speed_cat_slow
rule3 = speed_cat_cruise
rule4 = speed_cat_fast
rule5 = speed_cat_too_fast
# Then part of rules
imp1 = np.fmin(rule1,very_high)
imp2 = np.fmin(rule2,high)
imp3 = np.fmin(rule3,medium)
imp4 = np.fmin(rule4,low)
imp5 = np.fmin(rule5,very_low)
aggregate_membership = np.fmax(imp1,np.fmax(imp2,np.fmax(imp3,np.fmax(imp4,imp5))))
return fuzz.defuzz(throttle_value,aggregate_membership,'centroid')
def fuzzify(Input, y, crisp_val):
"""
Fuzzifies crisp value to obtain their membership values for corr. fuzzy subsets.
arguments:
Input - Range of crisp_val i.e, list of discrete x values which crisp_val can take
y - 2d list containing y values of each fuzzy subsets of an i/o variable
crisp_val - value to be fuzzified
"""
f = [fuzz.interp_membership(Input, fuzzy_sset_y, crisp_val) for fuzzy_sset_y in y]
return f
def fuzzyPOS(x,y,goal, direction='max', plot=False):
"""
Takes in a fuzzy membership function (x,y), finds dominance of the function
over the goal and returns the value.
------- INPUTS ------
x : list/array
x values for membership function
y : list/array
y values for membership function
goal : float
value of goal as crisp number
"""
try:
if plot:
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(x,y)
maxY = 0.999999*max(y) #maximum membership value
#yMs = fuzz.lambda_cut(y,maxY) (REMOVED THIS CAUSE IT SUCKED)
yMs = []
for i in range(len(y)):
if y[i] >= maxY: yMs.append(1)
else: yMs.append(0)
#print 'yMS', yMs
if direction is 'max':
maxX = max([i for i in range(len(yMs)) if yMs[i] == 1])
y2 = []
for i in range(len(y)):
if i <= maxX: y2.append(maxY) #extend function towards min (left)
else: y2.append(y[i])
if direction is 'min':
minX = min([i for i in range(len(yMs)) if yMs[i] == 1])
y2 = []
for i in range(len(y)):
if i >= minX: y2.append(maxY) #extend function towards max (right)
else: y2.append(y[i])
if plot:
ax.plot(x,y2, '--c')
ax.plot([goal, goal], [0.,1.], ':k')
ax.set_ylim([0.0,1.01])
plt.show()
d = fuzz.interp_membership(x,y2,goal)
return d
except:
e = sys.exc_info()[0]
print "Error calculating fuzzy POS:", e
return 0.0
def classify(self, r):
"""
For a given result (r) of action, determine the fuzzy membership.
Returns the class (0 to n) o associated with the result.
"""
try:
for subset, rules in self.rules.items():
aggregated, points = rules
m = [fuzz.interp_membership(self.x, mf, r) for mf in aggregated] # Calculate membership values
c = np.argmax(m)
return c
except Exception as error:
raise error
def calculate(self, p, i, d):
""" Calculates the fuzzy output gain """
# Calculate membership value for each function
if self.p_range is not None:
p_interp = {k: interp_membership(self.p_range, mf, p) for k, mf in self.p_mf.iteritems()}
print max(p_interp.iteritems(), key=operator.itemgetter(1))[0]
else:
p_interp = {}
if self.i_range is not None:
i_interp = {k: interp_membership(self.i_range, mf, i) for k, mf in self.i_mf.iteritems()}
print max(i_interp.iteritems(), key=operator.itemgetter(1))[0]
else:
i_interp = {}
if self.d_range is not None:
d_interp = {k: interp_membership(self.d_range, mf, d) for k, mf in self.d_mf.iteritems()}
print max(d_interp.iteritems(), key=operator.itemgetter(1))[0]
else:
d_interp = {}
# Merge rule-bases
dicts = [p_interp, i_interp, d_interp]
super_dict = {}
for k in set(k for d in dicts for k in d):
super_dict[k] = [d[k] for d in dicts if k in d]
# Generated inferences by rule implications
aggregate_membership = np.zeros(len(self.c_range))
for a,b,c in self.c_rules:
try:
impl = np.fmin(super_dict[a], super_dict[b]) * self.c_mf[c]
aggregate_membership = np.fmax(impl, aggregate_membership)
except:
pass
c = defuzz(self.c_range, aggregate_membership, 'centroid')
return c # this is the resulting "value" of the current state
def temp_error_category(self, current, target_temp, rate_of_change_per_minute):
te_current = float(current - target_temp)
te_too_cold_cat = fuzz.interp_membership(self.temp_err, self.te_too_cold, te_current)
te_cold_cat = fuzz.interp_membership(self.temp_err, self.te_cold, te_current)
te_optimal_cat = fuzz.interp_membership(self.temp_err, self.te_optimal, te_current)
te_hot_cat = fuzz.interp_membership(self.temp_err, self.te_hot, te_current)
te_too_hot_cat = fuzz.interp_membership(self.temp_err, self.te_too_hot, te_current)
tr_cooling_quickly = fuzz.interp_membership(self.temp_roc, self.tr_cooling_quickly, float(rate_of_change_per_minute))
return dict(too_cold=te_too_cold_cat,
cold=te_cold_cat,
optimal=te_optimal_cat,
hot=te_hot_cat,
too_hot=te_too_hot_cat,
cooling_quickly=tr_cooling_quickly)
def find_memberships(self):
'''
First we have to upsample the universe of self.var in order to add the
key points of the membership function based on the activation level
for this consequent, using the interp_universe function, which
interpolates the `xx` values in the universe such that its membership
function value is the activation level.
'''
# Find potentially new values
new_values = []
for label, term in self.var.terms.items():
term._cut = term.membership_value[self.sim]
if term._cut is None:
continue # No membership defined for this adjective
# Faster to aggregate as list w/duplication
new_values.extend(
_interp_universe_fast(
self.var.universe, term.mf, term._cut).tolist())
new_universe = np.union1d(self.var.universe, new_values)
# Initilize membership
output_mf = np.zeros_like(new_universe, dtype=np.float64)
# Build output membership function
term_mfs = {}
for label, term in self.var.terms.items():
if term._cut is None:
continue # No membership defined for this adjective
upsampled_mf = interp_membership(
self.var.universe, term.mf, new_universe)
term_mfs[label] = np.minimum(term._cut, upsampled_mf)
np.maximum(output_mf, term_mfs[label], output_mf)
return new_universe, output_mf, term_mfs
def find_memberships_nd(self, idx):
'''
Index-aware version of find_memberships(), expecting to select a
particular set of membership values from an array input, given input
``idx``.
'''
# Find potentially new values
new_values = []
for label, term in self.var.terms.items():
term._cut = term.membership_value[self.sim][idx]
if term._cut is None:
continue # No membership defined for this adjective
# Faster to aggregate as list w/duplication
new_values.extend(
_interp_universe_fast(
self.var.universe, term.mf, term._cut).tolist())
new_universe = np.union1d(self.var.universe, new_values)
# Initilize membership
output_mf = np.zeros_like(new_universe, dtype=np.float64)
# Build output membership function
term_mfs = {}
for label, term in self.var.terms.items():
if term._cut is None:
continue # No membership defined for this adjective
upsampled_mf = interp_membership(
self.var.universe, term.mf, new_universe)
term_mfs[label] = np.minimum(term._cut, upsampled_mf)
np.maximum(output_mf, term_mfs[label], output_mf)
return new_universe, output_mf
def error_fuzzify(inputs, b, error, delta_e):
f = [fuzz.interp_membership(inputs[0], fuzzy_set, error) for fuzzy_set in b[0]] #f : mu-value corresponding to error on fuzzy set.
f_d = [fuzz.interp_membership(inputs[1], fuzzy_set, delta_e) for fuzzy_set in b[1]]# f_d : mu-value corresponding to delta_e on fuzzy set.
return (f, f_d)
def geo_fuzzy_lingvo_scale(objects, cluster_id):
percentage = 0
average_profit = 0
profit_by_type = {geo_frame.columns[2]: 0, geo_frame.columns[3]: 0, geo_frame.columns[4]: 0}
for row, series in geo_frame.iterrows():
if row not in objects:
continue
average_profit += int(series[0])
percentage += int(series[1])
profit_by_type[geo_frame.columns[2]] += int(series[2])
profit_by_type[geo_frame.columns[3]] += int(series[3])
profit_by_type[geo_frame.columns[4]] += int(series[4])
for key in profit_by_type.keys():
profit_by_type[key] /= len(objects)
dominating_type = get_dominating_type(profit_by_type)
average_profit = round(average_profit / len(objects))
percentage = round(percentage / len(objects), 2)
# Generate universe variables
x_tendency = np.arange(0, 100, 1)
# Generate fuzzy membership functions
mfn_insignificant = fuzz.zmf(x_tendency, 0, 5)
mfn_low = fuzz.trimf(x_tendency, [5, 30, 30])
mfn_middle = fuzz.trimf(x_tendency, [30, 65, 65])
mfn_main = fuzz.trimf(x_tendency, [65, 100, 100])
# Visualize these universes and membership functions
fig, ax = plt.subplots(nrows=1, figsize=(8, 3))
ax.plot(x_tendency, mfn_insignificant, "r", linewidth=2.5, label="незначительная")
ax.plot(x_tendency, mfn_low, "r", linewidth=1, label="малая")
ax.plot(x_tendency, mfn_middle, "grey", linewidth=1, label="средняя")
ax.plot(x_tendency, mfn_main, "g", linewidth=1, label="основная")
ax.set_title("Доля выручки сегмента Big Data")
ax.legend()
# Turn off top/right axes
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)
ax.get_xaxis().tick_bottom()
ax.get_yaxis().tick_left()
plt.tight_layout()
fig.savefig("output/geo_fuzzy_scale.png")
# Interpretation
interp_insignificant = fuzz.interp_membership(x_tendency, mfn_insignificant, percentage)
interp_low = fuzz.interp_membership(x_tendency, mfn_low, percentage)
interp_middle = fuzz.interp_membership(x_tendency, mfn_middle, percentage)
interp_main = fuzz.interp_membership(x_tendency, mfn_main, percentage)
activation_insignificant = np.fmin(interp_insignificant, mfn_insignificant)
activation_low = np.fmin(interp_low, mfn_low)
activation_middle = np.fmin(interp_middle, mfn_middle)
activation_main = np.fmin(interp_main, mfn_main)
zeroes = np.zeros_like(x_tendency)
# Visualize this
fig, ax0 = plt.subplots(figsize=(8, 3))
ax0.fill_between(x_tendency, zeroes, activation_insignificant, facecolor="r", alpha=0.7)
ax0.plot(x_tendency, mfn_insignificant, "r", linewidth=2, linestyle="--", )
ax0.fill_between(x_tendency, zeroes, activation_low, facecolor="r", alpha=0.7)
ax0.plot(x_tendency, mfn_low, "r", linewidth=0.5, linestyle="--", )
ax0.fill_between(x_tendency, zeroes, activation_middle, facecolor="grey", alpha=0.7)
ax0.plot(x_tendency, mfn_middle, "grey", linewidth=0.5, linestyle="--")
ax0.fill_between(x_tendency, zeroes, activation_main, facecolor="g", alpha=0.7)
ax0.plot(x_tendency, mfn_main, "g", linewidth=0.5, linestyle="--")
ax0.set_title("Cluster: " + str(cluster_id))
# Turn off top/right axes
ax0.spines["top"].set_visible(False)
ax0.spines["right"].set_visible(False)
ax0.get_xaxis().tick_bottom()
ax0.get_yaxis().tick_left()
img = "geo_fuzzy_" + str(cluster_id) + ".png"
fig.savefig("output/" + img)
# Aggregate all output membership functions together
aggregated = np.fmax(activation_middle,
np.fmax(activation_main,
np.fmax(activation_low, activation_insignificant)))
# Calculate defuzzified result
tendency = fuzz.defuzz(x_tendency, aggregated, 'centroid')
# tendency_activation = fuzz.interp_membership(x_tendency, aggregated, tendency) # for plot
data_for_ui = None, None, None
if tendency <= 5:
data_for_ui = "danger", "glyphicon-arrow-down", "Незначительная"
elif 5 < tendency < 30:
data_for_ui = "danger", "glyphicon-arrow-down", "Малая"
elif 30 <= tendency < 65:
data_for_ui = "default", "glyphicon-minus", "Средняя"
elif 65 <= tendency < 100:
data_for_ui = "success", "glyphicon-arrow-up", "Основная"
return str("%.2f" % tendency), data_for_ui[0], data_for_ui[2], img, average_profit, dominating_type
def evalfis(input_throttle, input_speed):
if input_throttle >= 100:
print "Note: input throttle is over the limit 100"
input_throttle = 100
if input_speed >= 2.0:
print "Note: input speed is over the limit 2.0"
input_speed = 2.0
#print "input_throttle is "+ str(input_throttle)
#print "input_speed is "+ str(input_speed)
if input_throttle >= -15 and input_throttle <= 50:
t_level_gentle = fuzz.interp_membership(throttle_in, t_gentle, input_throttle)
else:
t_level_gentle = 0
#print "t_level_gentle" + str(t_level_gentle)
if (input_throttle >= 30 and input_throttle <= 75):
t_level_normal = fuzz.interp_membership(throttle_in, t_normal, input_throttle)
else:
t_level_normal = 0
#print "t_level_normal" + str(t_level_normal)
if (input_throttle >=50 and input_throttle<= 120):
t_level_hard = fuzz.interp_membership(throttle_in, t_hard, input_throttle)
else:
t_level_hard = 0
#print "t_level_hard" + str(t_level_hard)
#print t_level_hard
if (input_speed <= 1):
n_level_slow = fuzz.interp_membership(speed_in,n_slow,input_speed)
else:
n_level_slow = 0
#print "n_level_slow" + str(n_level_slow)
if (input_speed <= 1.2 and input_speed >= 0.8):
n_level_normal = fuzz.interp_membership(speed_in,n_normal,input_speed)
else:
n_level_normal = 0
#print "n_level_normal" + str(n_level_normal)
if (input_speed>=1 and input_speed <= 2):
n_level_fast = fuzz.interp_membership(speed_in,n_fast,input_speed)
else:
n_level_fast = 0
#print "n_level_fast" + str(n_level_fast)
R1 = min(t_level_gentle,n_level_slow)
R2 = min(t_level_gentle,n_level_normal)
R3 = min(t_level_normal,n_level_slow)
dr_activation_eco = np.fmin( max(R3, max(R1,R2)), d_eco )
#print "R1: %s, R2: %s, R3: %s" %(R1,R2,R3)
R4 = min(t_level_normal,n_level_normal)
dr_activation_mod = np.fmin(R4, d_mod)
#print "R4: %s" %(R4)
R5 = min(t_level_normal,n_level_fast)
R6 = min(t_level_gentle,n_level_fast)
R7 = t_level_hard
#print "R5: %s, R6: %s, R7: %s" %(R5,R6,R7)
dr_activation_agg = np.fmin( max(R7, max(R5,R6) ), d_agg )
############################## FOR DEBUGGING ######################
#fig, (ax0) = plt.subplots(nrows=1, figsize=(8, 9))
#ax0.plot(driving_behavior_in,dr_activation_eco, 'b', linewidth=1.5)
#ax0.plot(driving_behavior_in,dr_activation_mod, 'g', linewidth=1.5)
#ax0.plot(driving_behavior_in, dr_activation_agg, 'r', linewidth=1.5)
#ax0.set_title('driving_behavior')
#ax0.legend()
#plt.tight_layout()
#plt.show()
#stdin.readline()
###################################################################
# aggregate all seven output
aggregated = np.fmax(dr_activation_agg, np.fmax(dr_activation_mod,dr_activation_eco))
result = fuzz.defuzz(driving_behavior_in, aggregated, 'centroid')
#print ("fuzz result is " + str(result))
return result
r_dist_lo = fuzz.trimf(r_dist, levels[0]) r_dist_md = fuzz.trimf(r_dist, levels[1]) r_dist_hi = fuzz.trimf(r_dist, levels[2]) levels = adjust_levels(-2, 3, 0.25, True) l_power_lo = fuzz.trimf(l_power, levels[0]) l_power_md = fuzz.trimf(l_power, levels[1]) l_power_hi = fuzz.trimf(l_power, levels[2]) r_power_lo = fuzz.trimf(r_power, levels[0]) r_power_md = fuzz.trimf(r_power, levels[1]) r_power_hi = fuzz.trimf(r_power, levels[2]) # We need the activation of our fuzzy membership functions at these values. l_dist_level_lo = fuzz.interp_membership(l_dist, l_dist_lo, l_dist_sensor) l_dist_level_md = fuzz.interp_membership(l_dist, l_dist_md, l_dist_sensor) l_dist_level_hi = fuzz.interp_membership(l_dist, l_dist_hi, l_dist_sensor) r_dist_level_lo = fuzz.interp_membership(r_dist, r_dist_lo, r_dist_sensor) r_dist_level_md = fuzz.interp_membership(r_dist, r_dist_md, r_dist_sensor) r_dist_level_hi = fuzz.interp_membership(r_dist, r_dist_hi, r_dist_sensor) # Now we take our rules and apply them. active_rule1 = l_dist_level_lo active_rule2 = l_dist_level_md active_rule3 = l_dist_level_hi active_rule4 = r_dist_level_lo active_rule5 = r_dist_level_md
# Defuzzify this membership function five ways
defuzz_centroid = fuzz.defuzz(x, mfx, 'centroid') # Same as skfuzzy.centroid
defuzz_bisector = fuzz.defuzz(x, mfx, 'bisector')
defuzz_mom = fuzz.defuzz(x, mfx, 'mom')
defuzz_som = fuzz.defuzz(x, mfx, 'som')
defuzz_lom = fuzz.defuzz(x, mfx, 'lom')
# Collect info for vertical lines
labels = ['centroid', 'bisector', 'mean of maximum', 'min of maximum',
'max of maximum']
xvals = [defuzz_centroid,
defuzz_bisector,
defuzz_mom,
defuzz_som,
defuzz_lom]
colors = ['r', 'b', 'g', 'c', 'm']
ymax = [fuzz.interp_membership(x, mfx, i) for i in xvals]
# Display and compare defuzzification results against membership function
plt.figure(figsize=(8, 5))
plt.plot(x, mfx, 'k')
for xv, y, label, color in zip(xvals, ymax, labels, colors):
plt.vlines(xv, 0, y, label=label, color=color)
plt.ylabel('Fuzzy membership')
plt.xlabel('Universe variable (arb)')
plt.ylim(-0.1, 1.1)
plt.legend(loc=2)
plt.show()
kind of task at which fuzzy logic excels. Rule application ---------------- What would the tip be in the following circumstance: * Food *quality* was **6.5** * *Service* was **9.8** """ # We need the activation of our fuzzy membership functions at these values. # The exact values 6.5 and 9.8 do not exist on our universes... # This is what fuzz.interp_membership exists for! qual_level_lo = fuzz.interp_membership(x_qual, qual_lo, 6.5) qual_level_md = fuzz.interp_membership(x_qual, qual_md, 6.5) qual_level_hi = fuzz.interp_membership(x_qual, qual_hi, 6.5) serv_level_lo = fuzz.interp_membership(x_serv, serv_lo, 9.8) serv_level_md = fuzz.interp_membership(x_serv, serv_md, 9.8) serv_level_hi = fuzz.interp_membership(x_serv, serv_hi, 9.8) # Now we take our rules and apply them. Rule 1 concerns bad food OR service. # The OR operator means we take the maximum of these two. active_rule1 = np.fmax(qual_level_lo, serv_level_lo) # Now we apply this by clipping the top off the corresponding output # membership function with `np.fmin` tip_activation_lo = np.fmin(active_rule1, tip_lo) # removed entirely to 0
poin_hasil['debug']['cuaca_hujan'] = cuaca_hujan.tolist() poin_hasil['debug']['cuaca_sejuk'] = cuaca_sejuk.tolist() poin_hasil['debug']['cuaca_berawan'] = cuaca_berawan.tolist() poin_hasil['debug']['cuaca_cerah'] = cuaca_cerah.tolist() # Kategorisasi poin_suhu = [] poin_cahaya = [] poin_kelembapan = [] temperature = float(data['temperature']) lightIntensity = float(data['lightIntensity']) humidity = float(data['humidity']) poin_suhu.append(fuzz.interp_membership(suhu, suhu_rendah, temperature)) poin_suhu.append(fuzz.interp_membership(suhu, suhu_sedang, temperature)) poin_suhu.append(fuzz.interp_membership(suhu, suhu_tinggi, temperature)) poin_cahaya.append(fuzz.interp_membership(cahaya, cahaya_gelap, lightIntensity)) poin_cahaya.append(fuzz.interp_membership(cahaya, cahaya_sedang, lightIntensity)) poin_cahaya.append(fuzz.interp_membership(cahaya, cahaya_terang, lightIntensity)) poin_kelembapan.append(fuzz.interp_membership(kelembapan, kelembapan_rendah, humidity)) poin_kelembapan.append(fuzz.interp_membership(kelembapan, kelembapan_sedang, humidity)) poin_kelembapan.append(fuzz.interp_membership(kelembapan, kelembapan_tinggi, humidity)) poin_hasil['debug']['poin_suhu'] = poin_suhu poin_hasil['debug']['poin_cahaya'] = poin_cahaya poin_hasil['debug']['poin_kelembapan'] = poin_kelembapan
plt.tight_layout() """ """ .. image:: PLOT2RST.current_figure Fuzzy rules ----------- Now, to make these triangles useful, we define the *fuzzy relationship* between input and output variables. For the purposes of our example, consider two simple rules: 1. If age is half age AND blood pressure is low, then the insurance will be low 2. If age is young AND blood pressure is high, then the insurance will be high """ grau_intensidade_interacoes_AC_baixa = fuzz.interp_membership(x_intensidade_interacoes_AC, intensidade_interacoes_AC_baixa, intensidade_interacoes_AC) grau_intensidade_interacoes_AC_alta = fuzz.interp_membership(x_intensidade_interacoes_AC, intensidade_interacoes_AC_alta, intensidade_interacoes_AC) grau_intensidade_interacoes_BC_baixa = fuzz.interp_membership(x_intensidade_interacoes_BC, intensidade_interacoes_BC_baixa, intensidade_interacoes_BC) grau_intensidade_interacoes_BC_alta = fuzz.interp_membership(x_intensidade_interacoes_BC, intensidade_interacoes_BC_alta, intensidade_interacoes_BC) grau_similaridade_entre_vertices_baixa = fuzz.interp_membership(x_similaridade_entre_vertices, similaridade_entre_vertices_baixa, similaridade_entre_vertices) grau_similaridade_entre_vertices_alta = fuzz.interp_membership(x_similaridade_entre_vertices, similaridade_entre_vertices_alta, similaridade_entre_vertices) grau_idade_interacoes_AC_baixa = fuzz.interp_membership(x_idade_interacoes_AC, idade_interacoes_AC_baixa, idade_interacoes_AC) grau_idade_interacoes_AC_alta = fuzz.interp_membership(x_idade_interacoes_AC, idade_interacoes_AC_alta, idade_interacoes_AC) grau_idade_interacoes_BC_baixa = fuzz.interp_membership(x_idade_interacoes_BC, idade_interacoes_BC_baixa, idade_interacoes_BC) grau_idade_interacoes_BC_alta = fuzz.interp_membership(x_idade_interacoes_BC, idade_interacoes_BC_alta, idade_interacoes_BC)
def score_category(sc):
score_cat_ahead = fuzz.interp_membership(score, score_ahead, sc)
score_cat_tied = fuzz.interp_membership(score, score_tied, sc)
score_cat_behind = fuzz.interp_membership(score, score_behind, sc)
return dict(ahead = score_cat_ahead, tied = score_cat_tied, behind = score_cat_behind)
def fuzzylabels(ts, alts, spds, twindow=60):
'''
Fuzzy logic to determine the segments of the flight data
segments are: ground [GND], climb [CL], descend [DE], cruise [CR].
Default time window is 60 second.
'''
if len(ts) != len(alts):
raise RuntimeError('input ts and alts must have same length')
fltr = SavitzkyGolay(order=1, window_size=11)
_, alts = fltr.filter(ts, alts)
_, spds = fltr.filter(ts, spds)
labels = ['NA'] * len(ts)
# seprate data into chunks by window size
idxchunks = []
tchunks = []
altchunks = []
spdchunks = []
idxchk = []
tchk = []
altchk = []
spdchk = []
t0 = ts[0]
c = 1 # chunk number
idx = 0
for t, alt, spd in zip(ts, alts, spds):
if t > t0 + c * twindow:
if len(idxchk) > 2:
idxchunks.append(idxchk)
tchunks.append(tchk)
altchunks.append(altchk)
spdchunks.append(spdchk)
idxchk = []
tchk = []
altchk = []
spdchk = []
idxchk.append(idx)
tchk.append(t)
altchk.append(alt)
spdchk.append(spd)
c += 1
else:
idxchk.append(idx)
tchk.append(t)
altchk.append(alt)
spdchk.append(spd)
idx += 1
# add remaining parts from last iteration
idxchunks.append(idxchk)
tchunks.append(tchk)
altchunks.append(altchk)
for idxchk, tchk, altchk, spdchk \
in zip(idxchunks, tchunks, altchunks, spdchunks):
alt = np.mean(altchk)
spd = np.mean(spdchk)
if alt > alt_range[-1]:
alt = alt_range[-1]
if alt < alt_range[0]:
alt = alt_range[0]
if spd > spd_range[-1]:
spd = spd_range[-1]
if spd < spd_range[0]:
spd = spd_range[0]
lr = stats.linregress(xrange(len(altchk)), altchk)
dh = lr[0]
if dh > dh_range[-1]:
dh = dh_range[-1]
if dh < dh_range[0]:
dh = dh_range[0]
alt_level_gnd = fuzz.interp_membership(alt_range, alt_gnd, alt)
alt_level_lo = fuzz.interp_membership(alt_range, alt_lo, alt)
alt_level_hi = fuzz.interp_membership(alt_range, alt_hi, alt)
spd_level_hi = fuzz.interp_membership(spd_range, spd_hi, spd)
spd_level_md = fuzz.interp_membership(spd_range, spd_md, spd)
spd_level_lo = fuzz.interp_membership(spd_range, spd_lo, spd)
dh_level_zero = fuzz.interp_membership(dh_range, dh_zero, dh)
dh_level_plus = fuzz.interp_membership(dh_range, dh_plus, dh)
dh_level_minus = fuzz.interp_membership(dh_range, dh_minus, dh)
# print alt_level_gnd, alt_level_lo, alt_level_hi
# print dh_level_zero, dh_level_plus, dh_level_minus
# print spd_level_hi, spd_level_md, spd_level_lo
rule_ground = min(alt_level_gnd, spd_level_lo)
state_activate_ground = np.fmin(rule_ground, state_ground)
rule_climb = min(alt_level_lo, dh_level_plus, spd_level_md)
state_activate_climb = np.fmin(rule_climb, state_climb)
rule_descend = min(alt_level_lo, dh_level_minus, spd_level_md)
state_activate_descend = np.fmin(rule_descend, state_descend)
rule_cruise = min(alt_level_hi, dh_level_zero, spd_level_hi)
state_activate_cruise = np.fmin(rule_cruise, state_cruise)
aggregated = np.fmax(state_activate_ground,
np.fmax(state_activate_climb,
np.fmax(state_activate_descend,
state_activate_cruise)))
# print aggregated
state_raw = fuzz.defuzz(states, aggregated, 'lom')
state = int(round(state_raw))
state_lable_map = {1: 'GND', 2: 'CL', 3: 'DE', 4: 'CR'}
for i in idxchk:
labels[i] = state_lable_map[state]
return labels
def vassilis_defuzz(dism,disp,dor,cans):
dismenorreia = dism
dispareunia = disp
dorNasCostasPernas = dor
cansaco = cans
def nivel_leve_decresc(h):
return 5-(5*h)
def nivel_moderado_cresc(h):
return 5*h
def nivel_moderado_decresc(h):
return 10-(5*h)
def nivel_intenso_cresc(h):
return (5*h)+5
def nivel_dismenorreia_cresc(h):
return h + dismenorreia - 1
def nivel_dismenorreia_decresc(h):
return dismenorreia + 1 - h
def integrandoDismenorreiaLeve(h):
return (10+nivel_leve_decresc(h) - nivel_dismenorreia_cresc(h))/(10+nivel_dismenorreia_decresc(h) - nivel_dismenorreia_cresc(h))
def integrandoDismenorreiaModEsq(h):
return (10+nivel_dismenorreia_decresc(h) - nivel_moderado_cresc(h))/(10+nivel_dismenorreia_decresc(h) - nivel_dismenorreia_cresc(h))
def integrandoDismenorreiaModDir(h):
return (10+nivel_moderado_decresc(h) - nivel_dismenorreia_cresc(h))/(10+nivel_dismenorreia_decresc(h) - nivel_dismenorreia_cresc(h))
def integrandoDismenorreiaIntensa(h):
return (10+nivel_dismenorreia_cresc(h)-nivel_intenso_cresc(h))/(10+nivel_dismenorreia_decresc(h) - nivel_dismenorreia_cresc(h))
def dismenorreiaLeve():
h1 = 1 - (dismenorreia/6)
h2 = 1 - (dismenorreia/4)
if dismenorreia == 0:
return 1
elif h1 > 0 and h2 > 0:
return h2 + integrate.quad(integrandoDismenorreiaLeve, h2, h1)[0]
elif h1>0 and h2 <= 0:
return integrate.quad(integrandoDismenorreiaLeve, 0, h1)[0]
else:
return 0
def dismenorreiaModerada():
if dismenorreia < 5:
h1 = (dismenorreia/4) - (1/4)
h2 = (dismenorreia/6) - (1/6)
if h1 > 0 and h2 > 0:
return h1 + integrate.quad(integrandoDismenorreiaModEsq, h1, h2)[0]
elif h1 <= 0:
return integrate.quad(integrandoDismenorreiaModEsq, 0, h2)[0]
elif dismenorreia > 5:
h1 = (11/6)-(dismenorreia/6)
h2 = (9/4)-(dismenorreia/4)
if h1>0 and h2>0:
return h2 + integrate.quad(integrandoDismenorreiaModDir, h2, h1)[0]
elif h2 <= 0:
return integrate.quad(integrandoDismenorreiaModDir, 0, h1)[0]
else:
return 1
def dismenorreiaIntensa():
h1 = (dismenorreia/4) - (6/4)
h2 = (dismenorreia/6) - (4/6)
if dismenorreia == 10:
return 1
elif h1>0 and h2>0:
return h1 + integrate.quad(integrandoDismenorreiaIntensa, h1, h2)[0]
elif h2 > 0 and h1 <= 0:
return integrate.quad(integrandoDismenorreiaIntensa, 0, h2)[0]
else:
return 0
def nivel_dispareunia_cresc(h):
return h + dispareunia - 1
def nivel_dispareunia_decresc(h):
return dispareunia + 1 - h
def integrandoDispareuniaLeve(h):
return (10+nivel_leve_decresc(h) - nivel_dispareunia_cresc(h))/(10+nivel_dispareunia_decresc(h) - nivel_dispareunia_cresc(h))
def integrandoDispareuniaModEsq(h):
return (10+nivel_dispareunia_decresc(h) - nivel_moderado_cresc(h))/(10+nivel_dispareunia_decresc(h) - nivel_dispareunia_cresc(h))
def integrandoDispareuniaModDir(h):
return (10+nivel_moderado_decresc(h) - nivel_dispareunia_cresc(h))/(10+nivel_dispareunia_decresc(h) - nivel_dispareunia_cresc(h))
def integrandoDispareuniaIntensa(h):
return (10+nivel_dispareunia_cresc(h) - nivel_intenso_cresc(h))/(10+nivel_dispareunia_decresc(h) - nivel_dispareunia_cresc(h))
def dispareuniaLeve():
h1 = 1 - (dispareunia/6)
h2 = 1 - (dispareunia/4)
if dispareunia == 0:
return 1
elif h1 > 0 and h2 > 0:
return h2 + integrate.quad(integrandoDispareuniaLeve, h2, h1)[0]
elif h1>0 and h2 <= 0:
return integrate.quad(integrandoDispareuniaLeve, 0, h1)[0]
else:
return 0
def dispareuniaModerada():
if dispareunia < 5:
h1 = (dispareunia/4) - (1/4)
h2 = (dispareunia/6) - (1/6)
if h1 > 0 and h2 > 0:
return h1 + integrate.quad(integrandoDispareuniaModEsq, h1, h2)[0]
elif h1 <= 0:
return integrate.quad(integrandoDispareuniaModEsq, 0, h2)[0]
elif dispareunia > 5:
h1 = (11/6)-(dispareunia/6)
h2 = (9/4)-(dispareunia/4)
if h1>0 and h2>0:
return h2 + integrate.quad(integrandoDispareuniaModDir, h2, h1)[0]
elif h2 <= 0:
return integrate.quad(integrandoDispareuniaModDir, 0, h1)[0]
else:
return 1
def dispareuniaIntensa():
h1 = (dispareunia/4) - (6/4)
h2 = (dispareunia/6) - (4/6)
if dispareunia == 10:
return 1
elif h1>0 and h2>0:
return h1 + integrate.quad(integrandoDispareuniaIntensa, h1, h2)[0]
elif h2 > 0 and h1 <= 0:
return integrate.quad(integrandoDispareuniaIntensa, 0, h2)[0]
else:
return 0
def nivel_dorcp_cresc(h):
return h + dorNasCostasPernas - 1
def nivel_dorcp_decresc(h):
return dorNasCostasPernas + 1 - h
def integrandoDorCPLeve(h):
return (10+nivel_leve_decresc(h) - nivel_dorcp_cresc(h))/(10+nivel_dorcp_decresc(h) - nivel_dorcp_cresc(h))
def integrandoDorCPModEsq(h):
return (10+nivel_dorcp_decresc(h) - nivel_moderado_cresc(h))/(10+nivel_dorcp_decresc(h) - nivel_dorcp_cresc(h))
def integrandoDorCPModDir(h):
return (10+nivel_moderado_decresc(h) - nivel_dorcp_cresc(h))/(10+nivel_dorcp_decresc(h) - nivel_dorcp_cresc(h))
def integrandoDorCPIntensa(h):
return (10+nivel_dorcp_cresc(h) - nivel_intenso_cresc(h))/(10+nivel_dorcp_decresc(h) - nivel_dorcp_cresc(h))
def dorCPLeve():
h1 = 1 - (dorNasCostasPernas/6)
h2 = 1 - (dorNasCostasPernas/4)
if dorNasCostasPernas == 0:
return 1
elif h1 > 0 and h2 > 0:
return h2 + integrate.quad(integrandoDorCPLeve, h2, h1)[0]
elif h1>0 and h2 <= 0:
return integrate.quad(integrandoDorCPLeve, 0, h1)[0]
else:
return 0
def dorCPModerada():
if dorNasCostasPernas < 5:
h1 = (dorNasCostasPernas/4) - (1/4)
h2 = (dorNasCostasPernas/6) - (1/6)
if h1 > 0 and h2 > 0:
return h1 + integrate.quad(integrandoDorCPModEsq, h1, h2)[0]
elif h1 <= 0:
return integrate.quad(integrandoDorCPModDir, 0, h2)[0]
elif dorNasCostasPernas > 5:
h1 = (11/6)-(dorNasCostasPernas/6)
h2 = (9/4)-(dorNasCostasPernas/4)
if h1>0 and h2>0:
return h2 + integrate.quad(integrandoDorCPModDir, h2, h1)[0]
elif h2 <= 0:
return integrate.quad(integrandoDorCPModDir, 0, h1)[0]
else:
return 1
def dorCPIntensa():
h1 = (dorNasCostasPernas/4) - (6/4)
h2 = (dorNasCostasPernas/6) - (4/6)
if dorNasCostasPernas == 10:
return 1
elif h1>0 and h2>0:
return h1 + integrate.quad(integrandoDorCPIntensa, h1, h2)[0]
elif h2 > 0 and h1 <= 0:
return integrate.quad(integrandoDorCPIntensa, 0, h2)[0]
else:
return 0
def nivel_cansaco_cresc(h):
return h + cansaco - 1
def nivel_cansaco_decresc(h):
return cansaco + 1 - h
def integrandoCansacoLeve(h):
return (10+nivel_leve_decresc(h) - nivel_cansaco_cresc(h))/(10+nivel_cansaco_decresc(h) - nivel_cansaco_cresc(h))
def integrandoCansacoModEsq(h):
return (10+nivel_cansaco_decresc(h) - nivel_moderado_cresc(h))/(10+nivel_cansaco_decresc(h) - nivel_cansaco_cresc(h))
def integrandoCansacoModDir(h):
return (10+nivel_moderado_decresc(h) - nivel_cansaco_cresc(h))/(10+nivel_cansaco_decresc(h) - nivel_cansaco_cresc(h))
def integrandoCansacoIntensa(h):
return (10+nivel_cansaco_cresc(h) - nivel_intenso_cresc(h))/(10+nivel_cansaco_decresc(h) - nivel_cansaco_cresc(h))
def cansacoLeve():
h1 = 1 - (cansaco/6)
h2 = 1 - (cansaco/4)
if cansaco == 0:
return 1
elif h1 > 0 and h2 > 0:
return h2 + integrate.quad(integrandoCansacoLeve, h2, h1)[0]
elif h1>0 and h2 <= 0:
return integrate.quad(integrandoCansacoLeve, 0, h1)[0]
else:
return 0
def cansacoModerado():
if cansaco < 5:
h1 = (cansaco/4) - (1/4)
h2 = (cansaco/6) - (1/6)
if h1 > 0 and h2 > 0:
return h1 + integrate.quad(integrandoCansacoModEsq, h1, h2)[0]
elif h1 <= 0:
return integrate.quad(integrandoCansacoModEsq, 0, h2)[0]
elif cansaco > 5:
h1 = (11/6)-(cansaco/6)
h2 = (9/4)-(cansaco/4)
if h1>0 and h2>0:
return h2 + integrate.quad(integrandoCansacoModDir, h2, h1)[0]
elif h2 <= 0:
return integrate.quad(integrandoCansacoModDir, 0, h1)[0]
else:
return 1
def cansacoIntenso():
h1 = (cansaco/4) - (6/4)
h2 = (cansaco/6) - (4/6)
if cansaco == 10:
return 1
elif h1>0 and h2>0:
return h1 + integrate.quad(integrandoCansacoIntensa, h1, h2)[0]
elif h2 > 0 and h1 <= 0:
return integrate.quad(integrandoCansacoIntensa, 0, h2)[0]
else:
return 0
#Consequente
risco = np.arange(0,100,1) #nivel de risco de endometriose (0 a 10)
#Funcoes de pertinencia do Risco de Endometriose
risco_improvavel = fuzz.trimf(risco, [0,0,33]) #risco de endometriose baixo
risco_poucoprovavel = fuzz.trimf(risco, [0,33,66]) #risco de endometriose medio
risco_provavel = fuzz.trimf(risco, [33,66,100]) #risco de endometriose alto
risco_muitoprovavel = fuzz.trimf(risco, [66,100,100]) #risco de endometriose alto
## Simulando uma entrada com:
#Nivel de dismenorreia 10
dismenorreia_nivel_leve = dismenorreiaLeve()
dismenorreia_nivel_moderada = dismenorreiaModerada()
dismenorreia_nivel_intensa = dismenorreiaIntensa()
#Nivel de dispareunia 8
dispareunia_nivel_leve = dispareuniaLeve()
dispareunia_nivel_moderada = dispareuniaModerada()
dispareunia_nivel_intensa = dispareuniaIntensa()
#Nivel de dor nas costas/pernas 8
dorCP_nivel_leve = dorCPLeve()
dorCP_nivel_moderada = dorCPModerada()
dorCP_nivel_intensa = dorCPIntensa()
#Nivel de cansaco 9
cansaco_nivel_leve = cansacoLeve()
cansaco_nivel_moderado = cansacoModerado()
cansaco_nivel_intenso = cansacoIntenso()
regras_ativas = []
## Base de regras
#Regra 1: dismenorreia leve; dispareunia leve; dor costas/pernas leve; cansaco leve => risco improvavel
ativa_regra1 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra1 = np.fmin(ativa_regra1, risco_improvavel) #implicacao
if regra1.any() != 0:
regras_ativas.append(1)
#Regra 2: dismenorreia leve; dispareunia leve; dor costas/pernas leve; cansaco moderado => risco improvavel
ativa_regra2 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra2 = np.fmin(ativa_regra2, risco_improvavel) #implicacao
if regra2.any() != 0:
regras_ativas.append(2)
#Regra 3: dismenorreia leve; dispareunia leve; dor costas/pernas leve; cansaco intenso => risco pouco provavel
ativa_regra3 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra3 = np.fmin(ativa_regra3, risco_poucoprovavel) #implicacao
if regra3.any() != 0:
regras_ativas.append(3)
#Regra 4: dismenorreia leve; dispareunia leve; dor costas/pernas moderado; cansaco leve => risco improvavel
ativa_regra4 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra4 = np.fmin(ativa_regra4, risco_improvavel) #implicacao
if regra4.any() != 0:
regras_ativas.append(4)
#Regra 5: dismenorreia leve; dispareunia leve; dor costas/pernas moderado; cansaco moderado => risco improvavel
ativa_regra5 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra5 = np.fmin(ativa_regra5, risco_improvavel) #implicacao
if regra5.any() != 0:
regras_ativas.append(5)
#Regra 6: dismenorreia leve; dispareunia leve; dor costas/pernas moderado; cansaco intenso => risco pouco provavel
ativa_regra6 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra6 = np.fmin(ativa_regra6, risco_poucoprovavel) #implicacao
if regra6.any() != 0:
regras_ativas.append(6)
#Regra 7: dismenorreia leve; dispareunia leve; dor costas/pernas intenso; cansaco leve => risco pouco provavel
ativa_regra7 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra7 = np.fmin(ativa_regra7, risco_poucoprovavel) #implicacao
if regra7.any() != 0:
regras_ativas.append(7)
#Regra 8: dismenorreia leve; dispareunia leve; dor costas/pernas intenso; cansaco moderado => risco pouco provavel
ativa_regra8 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra8 = np.fmin(ativa_regra8, risco_poucoprovavel) #implicacao
if regra8.any() != 0:
regras_ativas.append(8)
#Regra 9: dismenorreia leve; dispareunia leve; dor costas/pernas intenso; cansaco intenso => risco provavel
ativa_regra9 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra9 = np.fmin(ativa_regra9, risco_provavel) #implicacao
if regra9.any() != 0:
regras_ativas.append(9)
#Regra 10: dismenorreia leve; dispareunia moderado; dor costas/pernas leve; cansaco leve => risco improvavel
ativa_regra10 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra10 = np.fmin(ativa_regra10, risco_improvavel) #implicacao
if regra10.any() != 0:
regras_ativas.append(10)
#Regra 11: dismenorreia leve; dispareunia moderado; dor costas/pernas leve; cansaco moderado => risco improvavel
ativa_regra11 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra11 = np.fmin(ativa_regra11, risco_improvavel) #implicacao
if regra11.any() != 0:
regras_ativas.append(11)
#Regra 12: dismenorreia leve; dispareunia moderado; dor costas/pernas leve; cansaco intenso => risco pouco provavel
ativa_regra12 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra12 = np.fmin(ativa_regra12, risco_poucoprovavel) #implicacao
if regra12.any() != 0:
regras_ativas.append(12)
#Regra 13: dismenorreia leve; dispareunia moderado; dor costas/pernas moderado; cansaco leve => risco improvavel
ativa_regra13 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra13 = np.fmin(ativa_regra13, risco_improvavel) #implicacao
if regra13.any() != 0:
regras_ativas.append(13)
#Regra 14: dismenorreia leve; dispareunia moderado; dor costas/pernas moderado; cansaco moderado => risco pouco provavel
ativa_regra14 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra14 = np.fmin(ativa_regra14, risco_poucoprovavel) #implicacao
if regra14.any() != 0:
regras_ativas.append(14)
#Regra 15: dismenorreia leve; dispareunia moderado; dor costas/pernas moderado; cansaco intenso => risco provavel
ativa_regra15 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra15 = np.fmin(ativa_regra15, risco_provavel) #implicacao
if regra15.any() != 0:
regras_ativas.append(15)
#Regra 16: dismenorreia leve; dispareunia moderado; dor costas/pernas intenso; cansaco leve => risco provavel
ativa_regra16 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra16 = np.fmin(ativa_regra16, risco_provavel) #implicacao
if regra16.any() != 0:
regras_ativas.append(16)
#Regra 17: dismenorreia leve; dispareunia moderado; dor costas/pernas intenso; cansaco moderado => risco provavel
ativa_regra17 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra17 = np.fmin(ativa_regra17, risco_provavel) #implicacao
if regra17.any() != 0:
regras_ativas.append(17)
#Regra 18: dismenorreia leve; dispareunia moderado; dor costas/pernas intenso; cansaco intenso => risco muito provavel
ativa_regra18 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra18 = np.fmin(ativa_regra18, risco_muitoprovavel) #implicacao
if regra18.any() != 0:
regras_ativas.append(18)
#Regra 19: dismenorreia leve; dispareunia intenso; dor costas/pernas leve; cansaco leve => risco improvavel
ativa_regra19 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra19 = np.fmin(ativa_regra19, risco_improvavel) #implicacao
if regra19.any() != 0:
regras_ativas.append(19)
#Regra 20: dismenorreia leve; dispareunia intenso; dor costas/pernas leve; cansaco moderado => risco pouco provavel
ativa_regra20 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra20 = np.fmin(ativa_regra20, risco_poucoprovavel) #implicacao
if regra20.any() != 0:
regras_ativas.append(20)
#Regra 21: dismenorreia leve; dispareunia intenso; dor costas/pernas leve; cansaco intenso => risco provavel
ativa_regra21 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra21 = np.fmin(ativa_regra21, risco_provavel) #implicacao
if regra21.any() != 0:
regras_ativas.append(21)
#Regra 22: dismenorreia leve; dispareunia intenso; dor costas/pernas moderado; cansaco leve => risco pouco provavel
ativa_regra22 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra22 = np.fmin(ativa_regra22, risco_poucoprovavel) #implicacao
if regra22.any() != 0:
regras_ativas.append(22)
#Regra 23: dismenorreia leve; dispareunia intenso; dor costas/pernas moderado; cansaco moderado => risco provavel
ativa_regra23 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra23 = np.fmin(ativa_regra23, risco_provavel) #implicacao
if regra23.any() != 0:
regras_ativas.append(23)
#Regra 24: dismenorreia leve; dispareunia intenso; dor costas/pernas moderado; cansaco intenso => risco muito provavel
ativa_regra24 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra24 = np.fmin(ativa_regra24, risco_muitoprovavel) #implicacao
if regra24.any() != 0:
regras_ativas.append(24)
#Regra 25: dismenorreia leve; dispareunia intenso; dor costas/pernas intenso; cansaco leve => risco pouco provavel
ativa_regra25 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra25 = np.fmin(ativa_regra25, risco_poucoprovavel) #implicacao
if regra25.any() != 0:
regras_ativas.append(25)
#Regra 26: dismenorreia leve; dispareunia intenso; dor costas/pernas intenso; cansaco moderado => risco provavel
ativa_regra26 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra26 = np.fmin(ativa_regra26, risco_provavel) #implicacao
if regra26.any() != 0:
regras_ativas.append(26)
#Regra 27: dismenorreia leve; dispareunia intenso; dor costas/pernas intenso; cansaco intenso => risco muito provavel
ativa_regra27 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra27 = np.fmin(ativa_regra27, risco_muitoprovavel) #implicacao
if regra27.any() != 0:
regras_ativas.append(27)
#Regra 28: dismenorreia moderado; dispareunia leve; dor costas/pernas leve; cansaco leve => risco improvavel
ativa_regra28 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra28 = np.fmin(ativa_regra28, risco_improvavel) #implicacao
if regra28.any() != 0:
regras_ativas.append(28)
#Regra 29: dismenorreia moderado; dispareunia leve; dor costas/pernas leve; cansaco moderado => risco improvavel
ativa_regra29 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra29 = np.fmin(ativa_regra29, risco_improvavel) #implicacao
if regra29.any() != 0:
regras_ativas.append(29)
#Regra 30: dismenorreia moderado; dispareunia leve; dor costas/pernas leve; cansaco intenso => risco improvavel
ativa_regra30 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra30 = np.fmin(ativa_regra30, risco_improvavel) #implicacao
if regra30.any() != 0:
regras_ativas.append(30)
#Regra 31: dismenorreia moderado; dispareunia leve; dor costas/pernas moderado; cansaco leve => risco pouco provavel
ativa_regra31 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra31 = np.fmin(ativa_regra31, risco_poucoprovavel) #implicacao
if regra31.any() != 0:
regras_ativas.append(31)
#Regra 32: dismenorreia moderado; dispareunia leve; dor costas/pernas moderado; cansaco moderado => risco pouco provavel
ativa_regra32 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra32 = np.fmin(ativa_regra32, risco_poucoprovavel) #implicacao
if regra32.any() != 0:
regras_ativas.append(32)
#Regra 33: dismenorreia moderado; dispareunia leve; dor costas/pernas moderado; cansaco intenso => risco provavel
ativa_regra33 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra33 = np.fmin(ativa_regra33, risco_provavel) #implicacao
if regra33.any() != 0:
regras_ativas.append(33)
#Regra 34: dismenorreia moderado; dispareunia leve; dor costas/pernas intenso; cansaco leve => risco provavel
ativa_regra34 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra34 = np.fmin(ativa_regra34, risco_provavel) #implicacao
if regra34.any() != 0:
regras_ativas.append(34)
#Regra 35: dismenorreia moderado; dispareunia leve; dor costas/pernas intenso; cansaco moderado => risco provavel
ativa_regra35 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra35 = np.fmin(ativa_regra35, risco_provavel) #implicacao
if regra35.any() != 0:
regras_ativas.append(35)
#Regra 36: dismenorreia moderado; dispareunia leve; dor costas/pernas intenso; cansaco intenso => risco muito provavel
ativa_regra36 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra36 = np.fmin(ativa_regra36, risco_muitoprovavel) #implicacao
if regra36.any() != 0:
regras_ativas.append(36)
#Regra 37: dismenorreia moderado; dispareunia moderado; dor costas/pernas leve; cansaco leve => risco improvavel
ativa_regra37 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra37 = np.fmin(ativa_regra37, risco_improvavel) #implicacao
if regra37.any() != 0:
regras_ativas.append(37)
#Regra 38: dismenorreia moderado; dispareunia moderado; dor costas/pernas leve; cansaco moderado => risco pouco provavel
ativa_regra38 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra38 = np.fmin(ativa_regra38, risco_poucoprovavel) #implicacao
if regra38.any() != 0:
regras_ativas.append(38)
#Regra 39: dismenorreia moderado; dispareunia moderado; dor costas/pernas leve; cansaco intenso => risco provavel
ativa_regra39 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra39 = np.fmin(ativa_regra39, risco_provavel) #implicacao
if regra39.any() != 0:
regras_ativas.append(39)
#Regra 40: dismenorreia moderado; dispareunia moderado; dor costas/pernas moderado; cansaco leve => risco improvavel
ativa_regra40 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra40 = np.fmin(ativa_regra40, risco_improvavel) #implicacao
if regra40.any() != 0:
regras_ativas.append(40)
#Regra 41: dismenorreia moderado; dispareunia moderado; dor costas/pernas moderado; cansaco moderado => risco pouco provavel
ativa_regra41 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra41 = np.fmin(ativa_regra41, risco_poucoprovavel) #implicacao
if regra41.any() != 0:
regras_ativas.append(41)
#Regra 42: dismenorreia moderado; dispareunia moderado; dor costas/pernas moderado; cansaco intenso => risco provavel
ativa_regra42 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra42 = np.fmin(ativa_regra42, risco_provavel) #implicacao
if regra42.any() != 0:
regras_ativas.append(42)
#Regra 43: dismenorreia moderado; dispareunia moderado; dor costas/pernas intenso; cansaco leve => risco provavel
ativa_regra43 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra43 = np.fmin(ativa_regra43, risco_provavel) #implicacao
if regra43.any() != 0:
regras_ativas.append(43)
#Regra 44: dismenorreia moderado; dispareunia moderado; dor costas/pernas intenso; cansaco moderado => risco provavel
ativa_regra44 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra44 = np.fmin(ativa_regra44, risco_provavel) #implicacao
if regra44.any() != 0:
regras_ativas.append(44)
#Regra 45: dismenorreia moderado; dispareunia moderado; dor costas/pernas intenso; cansaco intenso => risco muito provavel
ativa_regra45 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra45 = np.fmin(ativa_regra45, risco_muitoprovavel) #implicacao
if regra45.any() != 0:
regras_ativas.append(45)
#Regra 46: dismenorreia moderado; dispareunia intenso; dor costas/pernas leve; cansaco leve => risco pouco provavel
ativa_regra46 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra46 = np.fmin(ativa_regra46, risco_poucoprovavel) #implicacao
if regra46.any() != 0:
regras_ativas.append(46)
#Regra 47: dismenorreia moderado; dispareunia intenso; dor costas/pernas leve; cansaco moderado => risco provavel
ativa_regra47 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra47 = np.fmin(ativa_regra47, risco_provavel) #implicacao
if regra47.any() != 0:
regras_ativas.append(47)
#Regra 48: dismenorreia moderado; dispareunia intenso; dor costas/pernas leve; cansaco intenso => risco provavel
ativa_regra48 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra48 = np.fmin(ativa_regra48, risco_provavel) #implicacao
if regra48.any() != 0:
regras_ativas.append(48)
#Regra 49: dismenorreia moderado; dispareunia intenso; dor costas/pernas moderado; cansaco leve => risco provavel
ativa_regra49 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra49 = np.fmin(ativa_regra49, risco_provavel) #implicacao
if regra49.any() != 0:
regras_ativas.append(49)
#Regra 50: dismenorreia moderado; dispareunia intenso; dor costas/pernas moderado; cansaco moderado => risco provavel
ativa_regra50 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra50 = np.fmin(ativa_regra50, risco_provavel) #implicacao
if regra50.any() != 0:
regras_ativas.append(50)
#Regra 51: dismenorreia moderado; dispareunia intenso; dor costas/pernas moderado; cansaco intenso => risco muito provavel
ativa_regra51 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra51 = np.fmin(ativa_regra51, risco_muitoprovavel) #implicacao
if regra51.any() != 0:
regras_ativas.append(51)
#Regra 52: dismenorreia moderado; dispareunia intenso; dor costas/pernas intenso; cansaco leve => risco provavel
ativa_regra52 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra52 = np.fmin(ativa_regra52, risco_provavel) #implicacao
if regra52.any() != 0:
regras_ativas.append(52)
#Regra 53: dismenorreia moderado; dispareunia intenso; dor costas/pernas intenso; cansaco moderado => risco muito provavel
ativa_regra53 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra53 = np.fmin(ativa_regra53, risco_muitoprovavel) #implicacao
if regra53.any() != 0:
regras_ativas.append(53)
#Regra 54: dismenorreia moderado; dispareunia intenso; dor costas/pernas intenso; cansaco intenso => risco muito provavel
ativa_regra54 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra54 = np.fmin(ativa_regra54, risco_muitoprovavel) #implicacao
if regra54.any() != 0:
regras_ativas.append(54)
#Regra 55: dismenorreia intenso; dispareunia leve; dor costas/pernas leve; cansaco leve => risco improvavel
ativa_regra55 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra55 = np.fmin(ativa_regra55, risco_improvavel) #implicacao
if regra55.any() != 0:
regras_ativas.append(55)
#Regra 56: dismenorreia intenso; dispareunia leve; dor costas/pernas leve; cansaco moderado => risco improvavel
ativa_regra56 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra56 = np.fmin(ativa_regra56, risco_improvavel) #implicacao
if regra56.any() != 0:
regras_ativas.append(56)
#Regra 57: dismenorreia intenso; dispareunia leve; dor costas/pernas leve; cansaco intenso => risco pouco provavel
ativa_regra57 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra57 = np.fmin(ativa_regra57, risco_poucoprovavel) #implicacao
if regra57.any() != 0:
regras_ativas.append(57)
#Regra 58: dismenorreia intenso; dispareunia leve; dor costas/pernas moderado; cansaco leve => risco pouco provavel
ativa_regra58 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra58 = np.fmin(ativa_regra58, risco_poucoprovavel) #implicacao
if regra58.any() != 0:
regras_ativas.append(58)
#Regra 59: dismenorreia intenso; dispareunia leve; dor costas/pernas moderado; cansaco moderado => risco pouco provavel
ativa_regra59 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra59 = np.fmin(ativa_regra59, risco_poucoprovavel) #implicacao
if regra59.any() != 0:
regras_ativas.append(59)
#Regra 60: dismenorreia intenso; dispareunia leve; dor costas/pernas moderado; cansaco intenso => risco provavel
ativa_regra60 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra60 = np.fmin(ativa_regra60, risco_provavel) #implicacao
if regra60.any() != 0:
regras_ativas.append(60)
#Regra 61: dismenorreia intenso; dispareunia leve; dor costas/pernas intenso; cansaco leve => risco pouco provavel
ativa_regra61 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra61 = np.fmin(ativa_regra61, risco_poucoprovavel) #implicacao
if regra61.any() != 0:
regras_ativas.append(61)
#Regra 62: dismenorreia intenso; dispareunia leve; dor costas/pernas intenso; cansaco moderado => risco provavel
ativa_regra62 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra62 = np.fmin(ativa_regra62, risco_provavel) #implicacao
if regra62.any() != 0:
regras_ativas.append(62)
#Regra 63: dismenorreia intenso; dispareunia leve; dor costas/pernas intenso; cansaco intenso => risco muito provavel
ativa_regra63 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra63 = np.fmin(ativa_regra63, risco_muitoprovavel) #implicacao
if regra63.any() != 0:
regras_ativas.append(63)
#Regra 64: dismenorreia intenso; dispareunia moderado; dor costas/pernas leve; cansaco leve => risco pouco provavel
ativa_regra64 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra64 = np.fmin(ativa_regra64, risco_poucoprovavel) #implicacao
if regra64.any() != 0:
regras_ativas.append(64)
#Regra 65: dismenorreia intenso; dispareunia moderado; dor costas/pernas leve; cansaco moderado => risco pouco provavel
ativa_regra65 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra65 = np.fmin(ativa_regra65, risco_poucoprovavel) #implicacao
if regra65.any() != 0:
regras_ativas.append(65)
#Regra 66: dismenorreia intenso; dispareunia moderado; dor costas/pernas leve; cansaco intenso => risco provavel
ativa_regra66 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra66 = np.fmin(ativa_regra66, risco_provavel) #implicacao
if regra66.any() != 0:
regras_ativas.append(66)
#Regra 67: dismenorreia intenso; dispareunia moderado; dor costas/pernas moderado; cansaco leve => risco pouco provavel
ativa_regra67 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra67 = np.fmin(ativa_regra67, risco_poucoprovavel) #implicacao
if regra67.any() != 0:
regras_ativas.append(67)
#Regra 68: dismenorreia intenso; dispareunia moderado; dor costas/pernas moderado; cansaco moderado => risco provavel
ativa_regra68 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra68 = np.fmin(ativa_regra68, risco_provavel) #implicacao
if regra68.any() != 0:
regras_ativas.append(68)
#Regra 69: dismenorreia intenso; dispareunia moderado; dor costas/pernas moderado; cansaco intenso => risco provavel
ativa_regra69 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra69 = np.fmin(ativa_regra69, risco_provavel) #implicacao
if regra69.any() != 0:
regras_ativas.append(69)
#Regra 70: dismenorreia intenso; dispareunia moderado; dor costas/pernas intenso; cansaco leve => risco provavel
ativa_regra70 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra70 = np.fmin(ativa_regra70, risco_provavel) #implicacao
if regra70.any() != 0:
regras_ativas.append(70)
#Regra 71: dismenorreia intenso; dispareunia moderado; dor costas/pernas intenso; cansaco moderado => risco provavel
ativa_regra71 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra71 = np.fmin(ativa_regra71, risco_provavel) #implicacao
if regra71.any() != 0:
regras_ativas.append(71)
#Regra 72: dismenorreia intenso; dispareunia moderado; dor costas/pernas intenso; cansaco intenso => risco muito provavel
ativa_regra72 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra72 = np.fmin(ativa_regra72, risco_muitoprovavel) #implicacao
if regra72.any() != 0:
regras_ativas.append(72)
#Regra 73: dismenorreia intenso; dispareunia intenso; dor costas/pernas leve; cansaco leve => risco pouco provavel
ativa_regra73 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra73 = np.fmin(ativa_regra73, risco_poucoprovavel) #implicacao
if regra73.any() != 0:
regras_ativas.append(73)
#Regra 74: dismenorreia intenso; dispareunia intenso; dor costas/pernas leve; cansaco moderado => risco provavel
ativa_regra74 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra74 = np.fmin(ativa_regra74, risco_provavel) #implicacao
if regra74.any() != 0:
regras_ativas.append(74)
#Regra 75: dismenorreia intenso; dispareunia intenso; dor costas/pernas leve; cansaco intenso => risco muito provavel
ativa_regra75 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra75 = np.fmin(ativa_regra75, risco_muitoprovavel) #implicacao
if regra75.any() != 0:
regras_ativas.append(75)
#Regra 76: dismenorreia intenso; dispareunia intenso; dor costas/pernas moderado; cansaco leve => risco provavel
ativa_regra76 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra76 = np.fmin(ativa_regra76, risco_provavel) #implicacao
if regra76.any() != 0:
regras_ativas.append(76)
#Regra 77: dismenorreia intenso; dispareunia intenso; dor costas/pernas moderado; cansaco moderado => risco provavel
ativa_regra77 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra77 = np.fmin(ativa_regra77, risco_provavel) #implicacao
if regra77.any() != 0:
regras_ativas.append(77)
#Regra 78: dismenorreia intenso; dispareunia intenso; dor costas/pernas moderado; cansaco intenso => risco muito provavel
ativa_regra78 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra78 = np.fmin(ativa_regra78, risco_muitoprovavel) #implicacao
if regra78.any() != 0:
regras_ativas.append(78)
#Regra 79: dismenorreia intenso; dispareunia intenso; dor costas/pernas intenso; cansaco leve => risco muito provavel
ativa_regra79 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra79 = np.fmin(ativa_regra79, risco_muitoprovavel) #implicacao
if regra79.any() != 0:
regras_ativas.append(79)
#Regra 80: dismenorreia intenso; dispareunia intenso; dor costas/pernas intenso; cansaco moderado => risco muito provavel
ativa_regra80 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra80 = np.fmin(ativa_regra80, risco_muitoprovavel) #implicacao
if regra80.any() != 0:
regras_ativas.append(80)
#Regra 81: dismenorreia intenso; dispareunia intenso; dor costas/pernas intenso; cansaco intenso => risco muito provavel
ativa_regra81 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra81 = np.fmin(ativa_regra81, risco_muitoprovavel) #implicacao
if regra81.any() != 0:
regras_ativas.append(81)
print "regras ativas: "+str(regras_ativas)
## Agregacao das regras
agregacao = np.fmax(regra81,
np.fmax(regra80,
np.fmax(regra79,
np.fmax(regra78,
np.fmax(regra77,
np.fmax(regra76,
np.fmax(regra75,
np.fmax(regra74,
np.fmax(regra73,
np.fmax(regra72,
np.fmax(regra71,
np.fmax(regra70,
np.fmax(regra69,
np.fmax(regra68,
np.fmax(regra67,
np.fmax(regra66,
np.fmax(regra65,
np.fmax(regra64,
np.fmax(regra63,
np.fmax(regra62,
np.fmax(regra61,
np.fmax(regra60,
np.fmax(regra59,
np.fmax(regra58,
np.fmax(regra57,
np.fmax(regra56,
np.fmax(regra55,
np.fmax(regra54,
np.fmax(regra53,
np.fmax(regra52,
np.fmax(regra51,
np.fmax(regra50,
np.fmax(regra49,
np.fmax(regra48,
np.fmax(regra47,
np.fmax(regra46,
np.fmax(regra45,
np.fmax(regra44,
np.fmax(regra43,
np.fmax(regra42,
np.fmax(regra41,
np.fmax(regra40,
np.fmax(regra39,
np.fmax(regra38,
np.fmax(regra37,
np.fmax(regra36,
np.fmax(regra35,
np.fmax(regra34,
np.fmax(regra33,
np.fmax(regra32,
np.fmax(regra31,
np.fmax(regra30,
np.fmax(regra29,
np.fmax(regra28,
np.fmax(regra27,
np.fmax(regra26,
np.fmax(regra25,
np.fmax(regra24,
np.fmax(regra23,
np.fmax(regra22,
np.fmax(regra21,
np.fmax(regra20,
np.fmax(regra19,
np.fmax(regra18,
np.fmax(regra17,
np.fmax(regra16,
np.fmax(regra15,
np.fmax(regra14,
np.fmax(regra13,
np.fmax(regra12,
np.fmax(regra11,
np.fmax(regra10,
np.fmax(regra9,
np.fmax(regra8,
np.fmax(regra7,
np.fmax(regra6,
np.fmax(regra5,
np.fmax(regra4,
np.fmax(regra3,
np.fmax(regra1, regra2)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) #agregacao das regras
risco0 = np.zeros_like(risco) #variavel auxiliar para montar o grafico
## Calculo do resultado defuzzificado
risco_def = fuzz.defuzz(risco, agregacao, 'centroid') #defuzzificacao pelo metodo centroide
risco_ativacao = fuzz.interp_membership(risco, agregacao, risco_def) #intersecao do risco defuzzificado com a funcao de pertinencia
## Grafico da funcao de pertinencia resultante
fig, ax0 = plt.subplots(figsize=(9.27,3.23))
ax0.plot(risco, risco_improvavel, 'b', linewidth=0.5, label='I', linestyle='--')
ax0.plot(risco, risco_poucoprovavel, 'g', linewidth=0.5, label='PP', linestyle='--')
ax0.plot(risco, risco_provavel, 'y', linewidth=0.5, label='P', linestyle='--')
ax0.plot(risco, risco_muitoprovavel, 'r', linewidth=1.5, label='MP', linestyle='--')
ax0.legend(loc='upper center',bbox_to_anchor=(0.5, 1.05), ncol=4, fancybox=True, shadow=True)
ax0.fill_between(risco, risco0, agregacao, facecolor='Orange', alpha=0.7)
ax0.plot([risco_def, risco_def], [0, risco_ativacao], 'k', linewidth=1.5, alpha=0.9)
#ax0.annotate(str("{0:.1f}".format(risco_def))+"%", xy=(risco_def,risco_ativacao), xycoords='data')
plt.xticks(np.append(plt.xticks()[0],risco_def))
plt.xlabel('risco (%)')
ax0.set_title("Agregacao das regras e resultado defuzzificado")
plt.tight_layout()
plt.show()
return risco_def
# Food foo_r = fuzz.trapmf(food , [0, 0, 1, 3]) foo_d = fuzz.gaussmf(food, 10,1.5) # Output tip tip_ch = fuzz.trimf(tip, [0, 15, 30]) tip_ave = fuzz.trimf(tip, [25, 45, 70]) tip_gen = fuzz.trimf(tip, [60, 80, 100]) print 'tip_cheap', tip_ch print 'tip_average', tip_ave print 'tip_generous', tip_gen # Here I'll use your example service == 2 and food == 4 # These return a single value, which is combined using the rules in Step 3 # and operates on tip membership functions in Step 4 food_1 = fuzz.interp_membership(food, foo_r, 4.) food_3 = fuzz.interp_membership(food, foo_r, 4.) service_1 = fuzz.interp_membership(service, ser_p, 2) service_2 = fuzz.interp_membership(service, ser_g, 2) service_3 = fuzz.interp_membership(service, ser_e, 2) print 'food_1', food_1 print 'food_3', food_3 print 'service_1', service_1 print 'service_2', service_2 print 'service_3', service_3 # First rule is OR - this is a max operator rule1 = np.fmax(food_1, service_1) # Doable with inbuilt Python max(), but np.fmax is more general rule2 = service_2 # No combination, this is just passed rule3 = np.fmax(food_3, service_3) print 'rule1', rule1
def __init__(self, intensidade_interacoes_AC, intensidade_interacoes_BC, similaridade_entre_vertices, idade_interacoes_AC, idade_interacoes_BC):
print intensidade_interacoes_AC, intensidade_interacoes_BC, similaridade_entre_vertices, idade_interacoes_AC,idade_interacoes_BC
self.intensidade_interacoes_AC = intensidade_interacoes_AC
self.intensidade_interacoes_BC = intensidade_interacoes_BC
self.similaridade_entre_vertices = similaridade_entre_vertices
self.idade_interacoes_AC = idade_interacoes_AC
self.idade_interacoes_BC = idade_interacoes_BC
# Generate universe variables
self.x_intensidade_interacoes_AC = np.arange(0, 10, 1)
self.x_intensidade_interacoes_BC = np.arange(0, 10, 1)
self.x_similaridade_entre_vertices = np.arange(0, 101, 1)
self.x_idade_interacoes_AC = np.arange(0, 10, 1)
self.x_idade_interacoes_BC = np.arange(0, 10, 1)
self.x_potencial_ligacao = np.arange(0, 100, 1)
# Generate fuzzy membership functions
self.intensidade_interacoes_AC_baixa = fuzz.trimf(self.x_intensidade_interacoes_AC, [0, 0, 6])
self.intensidade_interacoes_AC_alta = fuzz.trapmf(self.x_intensidade_interacoes_AC, [2, 6, 10, 10])
self.intensidade_interacoes_BC_baixa = fuzz.trimf(self.x_intensidade_interacoes_BC, [0, 0, 6])
self.intensidade_interacoes_BC_alta = fuzz.trapmf(self.x_intensidade_interacoes_BC, [2, 6, 10, 10])
self.similaridade_entre_vertices_baixa = fuzz.trimf(self.x_similaridade_entre_vertices, [0, 0, 60])
self.similaridade_entre_vertices_alta = fuzz.trimf(self.x_similaridade_entre_vertices, [40, 100, 100])
self.idade_interacoes_AC_baixa = fuzz.trimf(self.x_idade_interacoes_AC, [0, 0, 6])
self.idade_interacoes_AC_alta = fuzz.trimf(self.x_idade_interacoes_AC, [4, 10, 10])
self.idade_interacoes_BC_baixa = fuzz.trimf(self.x_idade_interacoes_BC, [0, 0, 6])
self.idade_interacoes_BC_alta = fuzz.trimf(self.x_idade_interacoes_BC, [4, 10, 10])
self.potencial_ligacao_baixo = fuzz.trimf(self.x_potencial_ligacao, [0, 0, 60])
self.potencial_ligacao_medio = fuzz.trimf(self.x_potencial_ligacao, [10, 50, 90])
self.potencial_ligacao_alto = fuzz.trimf(self.x_potencial_ligacao, [40, 100, 100])
self.grau_intensidade_interacoes_AC_baixa = fuzz.interp_membership(self.x_intensidade_interacoes_AC, self.intensidade_interacoes_AC_baixa, intensidade_interacoes_AC)
self.grau_intensidade_interacoes_AC_alta = fuzz.interp_membership(self.x_intensidade_interacoes_AC, self.intensidade_interacoes_AC_alta, intensidade_interacoes_AC)
self.grau_intensidade_interacoes_BC_baixa = fuzz.interp_membership(self.x_intensidade_interacoes_BC, self.intensidade_interacoes_BC_baixa, intensidade_interacoes_BC)
self.grau_intensidade_interacoes_BC_alta = fuzz.interp_membership(self.x_intensidade_interacoes_BC, self.intensidade_interacoes_BC_alta, intensidade_interacoes_BC)
self.grau_similaridade_entre_vertices_baixa = fuzz.interp_membership(self.x_similaridade_entre_vertices, self.similaridade_entre_vertices_baixa, similaridade_entre_vertices)
self.grau_similaridade_entre_vertices_alta = fuzz.interp_membership(self.x_similaridade_entre_vertices, self.similaridade_entre_vertices_alta, similaridade_entre_vertices)
self.grau_idade_interacoes_AC_baixa = fuzz.interp_membership(self.x_idade_interacoes_AC, self.idade_interacoes_AC_baixa, self.idade_interacoes_AC)
self.grau_idade_interacoes_AC_alta = fuzz.interp_membership(self.x_idade_interacoes_AC, self.idade_interacoes_AC_alta, self.idade_interacoes_AC)
self.grau_idade_interacoes_BC_baixa = fuzz.interp_membership(self.x_idade_interacoes_BC, self.idade_interacoes_BC_baixa, self.idade_interacoes_BC)
self.grau_idade_interacoes_BC_alta = fuzz.interp_membership(self.x_idade_interacoes_BC, self.idade_interacoes_BC_alta, self.idade_interacoes_BC)
active_rule1 = np.fmin(self.grau_intensidade_interacoes_AC_alta, np.fmin(self.grau_intensidade_interacoes_BC_alta, np.fmin(self.grau_similaridade_entre_vertices_alta, np.fmin(self.grau_idade_interacoes_AC_baixa, self.grau_idade_interacoes_BC_baixa))))
potencial_ligacao_rule1 = np.fmin(active_rule1, self.potencial_ligacao_alto)
print('active_rule1 ', active_rule1)
active_rule2 = np.fmin(self.grau_intensidade_interacoes_AC_baixa, np.fmin(self.grau_intensidade_interacoes_BC_baixa, np.fmin(self.grau_similaridade_entre_vertices_baixa, np.fmin(self.grau_idade_interacoes_AC_alta, self.grau_idade_interacoes_BC_alta))))
potencial_ligacao_rule2 = np.fmin(active_rule2, self.potencial_ligacao_baixo)
print('active_rule2 ', active_rule2)
#print('potencial_ligacao_rule2 ', potencial_ligacao_rule2)
active_rule3 = np.fmin(self.grau_intensidade_interacoes_AC_alta, np.fmin(self.grau_intensidade_interacoes_BC_alta, np.fmin(self.grau_similaridade_entre_vertices_baixa, np.fmin(self.grau_idade_interacoes_AC_baixa, self.grau_idade_interacoes_BC_baixa))))
potencial_ligacao_rule3 = np.fmin(active_rule3, self.potencial_ligacao_medio)
print('active_rule3 ', active_rule3)
#print('potencial_ligacao_rule3 ', potencial_ligacao_rule3)
active_rule4 = np.fmin(self.grau_intensidade_interacoes_AC_baixa, np.fmin(self.grau_intensidade_interacoes_BC_baixa, np.fmin(self.grau_similaridade_entre_vertices_alta, np.fmin(self.grau_idade_interacoes_AC_baixa, self.grau_idade_interacoes_BC_baixa))))
potencial_ligacao_rule4 = np.fmin(active_rule4, self.potencial_ligacao_medio)
print('active_rule4 ', active_rule4)
#print('potencial_ligacao_rule4 ', potencial_ligacao_rule4)
# Aggregate all three output membership functions together
aggregated = np.fmax(potencial_ligacao_rule1,
np.fmax(potencial_ligacao_rule2, np.fmax(potencial_ligacao_rule3, potencial_ligacao_rule4)))
# Calculate defuzzified result
self.potencial_ligacao = fuzz.defuzz(self.x_potencial_ligacao, aggregated, 'centroid')
self.grau_potencial_ligacao = fuzz.interp_membership(self.x_potencial_ligacao, aggregated, self.potencial_ligacao)
def mamdani_defuzz(dism, disp, dor, cans):
dismenorreia = dism
dispareunia = disp
dorNasCostasPernas = dor
cansaco = cans
def nivelLeve(entrada):
if entrada == 0:
return 1
elif entrada >= 6:
return 0
else:
return 1 - (entrada/6)
def nivelModerado(entrada):
if entrada == 5:
return 1
elif entrada < 5:
return (entrada/6) - (1/6)
else:
return (11/6)-(entrada/6)
def nivelIntenso(entrada):
if entrada == 10:
return 1
elif entrada <=4:
return 0
else:
return (entrada/6) - (4/6)
#Antecedentes
dismenorreia_dominio = np.arange(0,11,0.1) #nivel de dismenorreia (0 a 10)
dispareunia_dominio = np.arange(0,11,1) #nivel de dispareunia (0 a 10)
dorNasCostasPernas_dominio = np.arange(0,11,1) #nivel de dor nas costas/pernas (0 a 10)
cansaco_dominio = np.arange(0,11,1) #nivel de cansaco (0 a 10)
#Consequente
risco = np.arange(0,100,1) #nivel de risco de endometriose (0 a 10)
#Funcoes de pertinencia de dismenorreia
dismenorreia_leve = fuzz.trimf(dismenorreia_dominio, [0,0,5]) #dismenorreia leve
dismenorreia_moderada = fuzz.trimf(dismenorreia_dominio, [0,5,10]) #dismenorreia moderada
dismenorreia_intensa = fuzz.trimf(dismenorreia_dominio, [5,10,10]) #dismenorreia intensa
#Funcoes de pertinencia de dispareunia
dispareunia_leve = fuzz.trimf(dispareunia_dominio, [0,0,5]) #dispareunia leve
dispareunia_moderada = fuzz.trimf(dispareunia_dominio, [0,5,10]) #dispareunia moderada
dispareunia_intensa = fuzz.trimf(dispareunia_dominio, [5,10,10]) #dispareunia intensa
#Funcoes de pertinencia de Dor Nas Costas e Pernas
dorCP_leve = fuzz.trimf(dorNasCostasPernas_dominio, [0,0,5]) #dor nas costas e/ou pernas leve
dorCP_moderada = fuzz.trimf(dorNasCostasPernas_dominio, [0,5,10]) #dor nas costas e/ou pernas moderada
dorCP_intensa = fuzz.trimf(dorNasCostasPernas_dominio, [5,10,10]) #dor nas costas e/ou pernas intensa
#Funcoes de pertinencia de cansaco
cansaco_leve = fuzz.trimf(cansaco_dominio, [0,0,5]) #cansaco leve
cansaco_moderado = fuzz.trimf(cansaco_dominio, [0,5,10]) #cansaco moderada
cansaco_intenso = fuzz.trimf(cansaco_dominio, [5,10,10]) #cansaco intensa
#Funcoes de pertinencia do Risco de Endometriose
risco_improvavel = fuzz.trimf(risco, [0,0,33]) #risco de endometriose baixo
risco_poucoprovavel = fuzz.trimf(risco, [0,33,66]) #risco de endometriose medio
risco_provavel = fuzz.trimf(risco, [33,66,100]) #risco de endometriose alto
risco_muitoprovavel = fuzz.trimf(risco, [66,100,100]) #risco de endometriose alto
## Simulando uma entrada
#dismenorreia_nivel_leve = fuzz.interp_membership(dismenorreia_dominio, dismenorreia_leve, dismenorreia) #faz a intersecao da entrada (10) com a funcao de pertinencia da dismenorreia leve
dismenorreia_nivel_leve = nivelLeve(dismenorreia)
#dismenorreia_nivel_moderada = fuzz.interp_membership(dismenorreia_dominio, dismenorreia_moderada, dismenorreia) #faz a intersecao da entrada (10) com a funcao de pertinencia da dismenorreia moderada
dismenorreia_nivel_moderada = nivelModerado(dismenorreia)
#dismenorreia_nivel_intensa = fuzz.interp_membership(dismenorreia_dominio, dismenorreia_intensa, dismenorreia) #faz a intersecao da entrada (10) com a funcao de pertinencia da dismenorreia intensa
dismenorreia_nivel_intensa = nivelIntenso(dismenorreia)
#dispareunia_nivel_leve = fuzz.interp_membership(dispareunia_dominio, dispareunia_leve, dispareunia) #faz a intersecao da entrada (8) com a funcao de pertinencia da dispareunia leve
dispareunia_nivel_leve = nivelLeve(dispareunia)
#dispareunia_nivel_moderada = fuzz.interp_membership(dispareunia_dominio, dispareunia_moderada, dispareunia) #faz a intersecao da entrada (8) com a funcao de pertinencia da dispareunia moderada
dispareunia_nivel_moderada = nivelModerado(dispareunia)
#dispareunia_nivel_intensa = fuzz.interp_membership(dispareunia_dominio, dispareunia_intensa, dispareunia) #faz a intersecao da entrada (8) com a funcao de pertinencia da dispareunia instensa
dispareunia_nivel_intensa = nivelIntenso(dispareunia)
#dorCP_nivel_leve = fuzz.interp_membership(dorNasCostasPernas_dominio, dorCP_leve, dorNasCostasPernas) #faz a intersecao da entrada (8) com a funcao de pertinencia da dor nas costas/pernas leve
dorCP_nivel_leve = nivelLeve(dorNasCostasPernas)
#dorCP_nivel_moderada = fuzz.interp_membership(dorNasCostasPernas_dominio, dorCP_moderada, dorNasCostasPernas) #faz a intersecao da entrada (8) com a funcao de pertinencia da dor nas costas/pernas moderada
dorCP_nivel_moderada = nivelModerado(dorNasCostasPernas)
#dorCP_nivel_intensa = fuzz.interp_membership(dorNasCostasPernas_dominio, dorCP_intensa, dorNasCostasPernas) #faz a intersecao da entrada (8) com a funcao de pertinencia da dor nas costas/pernas intensa
dorCP_nivel_intensa = nivelIntenso(dorNasCostasPernas)
#cansaco_nivel_leve = fuzz.interp_membership(cansaco_dominio, cansaco_leve, cansaco) #faz a intersecao da entrada (9) com a funcao de pertinencia de cansaco leve
cansaco_nivel_leve = nivelLeve(cansaco)
#cansaco_nivel_moderado = fuzz.interp_membership(cansaco_dominio, cansaco_moderado, cansaco) #faz a intersecao da entrada (9) com a funcao de pertinencia de cansaco moderado
cansaco_nivel_moderado = nivelModerado(cansaco)
#cansaco_nivel_intenso = fuzz.interp_membership(cansaco_dominio, cansaco_intenso, cansaco) #faz a intersecao da entrada (9) com a funcao de pertinencia de cansaco intenso
cansaco_nivel_intenso = nivelIntenso(cansaco)
regras_ativas = []
## Base de regras
#Regra 1: dismenorreia leve; dispareunia leve; dor costas/pernas leve; cansaco leve => risco improvavel
ativa_regra1 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra1 = np.fmin(ativa_regra1, risco_improvavel) #implicacao
if regra1.any() != 0:
regras_ativas.append(1)
#Regra 2: dismenorreia leve; dispareunia leve; dor costas/pernas leve; cansaco moderado => risco improvavel
ativa_regra2 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra2 = np.fmin(ativa_regra2, risco_improvavel) #implicacao
if regra2.any() != 0:
regras_ativas.append(2)
#Regra 3: dismenorreia leve; dispareunia leve; dor costas/pernas leve; cansaco intenso => risco pouco provavel
ativa_regra3 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra3 = np.fmin(ativa_regra3, risco_poucoprovavel) #implicacao
if regra3.any() != 0:
regras_ativas.append(3)
#Regra 4: dismenorreia leve; dispareunia leve; dor costas/pernas moderado; cansaco leve => risco improvavel
ativa_regra4 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra4 = np.fmin(ativa_regra4, risco_improvavel) #implicacao
if regra4.any() != 0:
regras_ativas.append(4)
#Regra 5: dismenorreia leve; dispareunia leve; dor costas/pernas moderado; cansaco moderado => risco improvavel
ativa_regra5 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra5 = np.fmin(ativa_regra5, risco_improvavel) #implicacao
if regra5.any() != 0:
regras_ativas.append(5)
#Regra 6: dismenorreia leve; dispareunia leve; dor costas/pernas moderado; cansaco intenso => risco pouco provavel
ativa_regra6 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra6 = np.fmin(ativa_regra6, risco_poucoprovavel) #implicacao
if regra6.any() != 0:
regras_ativas.append(6)
#Regra 7: dismenorreia leve; dispareunia leve; dor costas/pernas intenso; cansaco leve => risco pouco provavel
ativa_regra7 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra7 = np.fmin(ativa_regra7, risco_poucoprovavel) #implicacao
if regra7.any() != 0:
regras_ativas.append(7)
#Regra 8: dismenorreia leve; dispareunia leve; dor costas/pernas intenso; cansaco moderado => risco pouco provavel
ativa_regra8 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra8 = np.fmin(ativa_regra8, risco_poucoprovavel) #implicacao
if regra8.any() != 0:
regras_ativas.append(8)
#Regra 9: dismenorreia leve; dispareunia leve; dor costas/pernas intenso; cansaco intenso => risco provavel
ativa_regra9 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra9 = np.fmin(ativa_regra9, risco_provavel) #implicacao
if regra9.any() != 0:
regras_ativas.append(9)
#Regra 10: dismenorreia leve; dispareunia moderado; dor costas/pernas leve; cansaco leve => risco improvavel
ativa_regra10 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra10 = np.fmin(ativa_regra10, risco_improvavel) #implicacao
if regra10.any() != 0:
regras_ativas.append(10)
#Regra 11: dismenorreia leve; dispareunia moderado; dor costas/pernas leve; cansaco moderado => risco improvavel
ativa_regra11 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra11 = np.fmin(ativa_regra11, risco_improvavel) #implicacao
if regra11.any() != 0:
regras_ativas.append(11)
#Regra 12: dismenorreia leve; dispareunia moderado; dor costas/pernas leve; cansaco intenso => risco pouco provavel
ativa_regra12 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra12 = np.fmin(ativa_regra12, risco_poucoprovavel) #implicacao
if regra12.any() != 0:
regras_ativas.append(12)
#Regra 13: dismenorreia leve; dispareunia moderado; dor costas/pernas moderado; cansaco leve => risco improvavel
ativa_regra13 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra13 = np.fmin(ativa_regra13, risco_improvavel) #implicacao
if regra13.any() != 0:
regras_ativas.append(13)
#Regra 14: dismenorreia leve; dispareunia moderado; dor costas/pernas moderado; cansaco moderado => risco pouco provavel
ativa_regra14 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra14 = np.fmin(ativa_regra14, risco_poucoprovavel) #implicacao
if regra14.any() != 0:
regras_ativas.append(14)
#Regra 15: dismenorreia leve; dispareunia moderado; dor costas/pernas moderado; cansaco intenso => risco provavel
ativa_regra15 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra15 = np.fmin(ativa_regra15, risco_provavel) #implicacao
if regra15.any() != 0:
regras_ativas.append(15)
#Regra 16: dismenorreia leve; dispareunia moderado; dor costas/pernas intenso; cansaco leve => risco provavel
ativa_regra16 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra16 = np.fmin(ativa_regra16, risco_provavel) #implicacao
if regra16.any() != 0:
regras_ativas.append(16)
#Regra 17: dismenorreia leve; dispareunia moderado; dor costas/pernas intenso; cansaco moderado => risco provavel
ativa_regra17 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra17 = np.fmin(ativa_regra17, risco_provavel) #implicacao
if regra17.any() != 0:
regras_ativas.append(17)
#Regra 18: dismenorreia leve; dispareunia moderado; dor costas/pernas intenso; cansaco intenso => risco muito provavel
ativa_regra18 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra18 = np.fmin(ativa_regra18, risco_muitoprovavel) #implicacao
if regra18.any() != 0:
regras_ativas.append(18)
#Regra 19: dismenorreia leve; dispareunia intenso; dor costas/pernas leve; cansaco leve => risco improvavel
ativa_regra19 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra19 = np.fmin(ativa_regra19, risco_improvavel) #implicacao
if regra19.any() != 0:
regras_ativas.append(19)
#Regra 20: dismenorreia leve; dispareunia intenso; dor costas/pernas leve; cansaco moderado => risco pouco provavel
ativa_regra20 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra20 = np.fmin(ativa_regra20, risco_poucoprovavel) #implicacao
if regra20.any() != 0:
regras_ativas.append(20)
#Regra 21: dismenorreia leve; dispareunia intenso; dor costas/pernas leve; cansaco intenso => risco provavel
ativa_regra21 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra21 = np.fmin(ativa_regra21, risco_provavel) #implicacao
if regra21.any() != 0:
regras_ativas.append(21)
#Regra 22: dismenorreia leve; dispareunia intenso; dor costas/pernas moderado; cansaco leve => risco pouco provavel
ativa_regra22 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra22 = np.fmin(ativa_regra22, risco_poucoprovavel) #implicacao
if regra22.any() != 0:
regras_ativas.append(22)
#Regra 23: dismenorreia leve; dispareunia intenso; dor costas/pernas moderado; cansaco moderado => risco provavel
ativa_regra23 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra23 = np.fmin(ativa_regra23, risco_provavel) #implicacao
if regra23.any() != 0:
regras_ativas.append(23)
#Regra 24: dismenorreia leve; dispareunia intenso; dor costas/pernas moderado; cansaco intenso => risco muito provavel
ativa_regra24 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra24 = np.fmin(ativa_regra24, risco_muitoprovavel) #implicacao
if regra24.any() != 0:
regras_ativas.append(24)
#Regra 25: dismenorreia leve; dispareunia intenso; dor costas/pernas intenso; cansaco leve => risco pouco provavel
ativa_regra25 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra25 = np.fmin(ativa_regra25, risco_poucoprovavel) #implicacao
if regra25.any() != 0:
regras_ativas.append(25)
#Regra 26: dismenorreia leve; dispareunia intenso; dor costas/pernas intenso; cansaco moderado => risco provavel
ativa_regra26 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra26 = np.fmin(ativa_regra26, risco_provavel) #implicacao
if regra26.any() != 0:
regras_ativas.append(26)
#Regra 27: dismenorreia leve; dispareunia intenso; dor costas/pernas intenso; cansaco intenso => risco muito provavel
ativa_regra27 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_leve, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra27 = np.fmin(ativa_regra27, risco_muitoprovavel) #implicacao
if regra27.any() != 0:
regras_ativas.append(27)
#Regra 28: dismenorreia moderado; dispareunia leve; dor costas/pernas leve; cansaco leve => risco improvavel
ativa_regra28 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra28 = np.fmin(ativa_regra28, risco_improvavel) #implicacao
if regra28.any() != 0:
regras_ativas.append(28)
#Regra 29: dismenorreia moderado; dispareunia leve; dor costas/pernas leve; cansaco moderado => risco improvavel
ativa_regra29 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra29 = np.fmin(ativa_regra29, risco_improvavel) #implicacao
if regra29.any() != 0:
regras_ativas.append(29)
#Regra 30: dismenorreia moderado; dispareunia leve; dor costas/pernas leve; cansaco intenso => risco improvavel
ativa_regra30 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra30 = np.fmin(ativa_regra30, risco_improvavel) #implicacao
if regra30.any() != 0:
regras_ativas.append(30)
#Regra 31: dismenorreia moderado; dispareunia leve; dor costas/pernas moderado; cansaco leve => risco pouco provavel
ativa_regra31 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra31 = np.fmin(ativa_regra31, risco_poucoprovavel) #implicacao
if regra31.any() != 0:
regras_ativas.append(31)
#Regra 32: dismenorreia moderado; dispareunia leve; dor costas/pernas moderado; cansaco moderado => risco pouco provavel
ativa_regra32 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra32 = np.fmin(ativa_regra32, risco_poucoprovavel) #implicacao
if regra32.any() != 0:
regras_ativas.append(32)
#Regra 33: dismenorreia moderado; dispareunia leve; dor costas/pernas moderado; cansaco intenso => risco provavel
ativa_regra33 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra33 = np.fmin(ativa_regra33, risco_provavel) #implicacao
if regra33.any() != 0:
regras_ativas.append(33)
#Regra 34: dismenorreia moderado; dispareunia leve; dor costas/pernas intenso; cansaco leve => risco provavel
ativa_regra34 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra34 = np.fmin(ativa_regra34, risco_provavel) #implicacao
if regra34.any() != 0:
regras_ativas.append(34)
#Regra 35: dismenorreia moderado; dispareunia leve; dor costas/pernas intenso; cansaco moderado => risco provavel
ativa_regra35 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra35 = np.fmin(ativa_regra35, risco_provavel) #implicacao
if regra35.any() != 0:
regras_ativas.append(35)
#Regra 36: dismenorreia moderado; dispareunia leve; dor costas/pernas intenso; cansaco intenso => risco muito provavel
ativa_regra36 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra36 = np.fmin(ativa_regra36, risco_muitoprovavel) #implicacao
if regra36.any() != 0:
regras_ativas.append(36)
#Regra 37: dismenorreia moderado; dispareunia moderado; dor costas/pernas leve; cansaco leve => risco improvavel
ativa_regra37 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra37 = np.fmin(ativa_regra37, risco_improvavel) #implicacao
if regra37.any() != 0:
regras_ativas.append(37)
#Regra 38: dismenorreia moderado; dispareunia moderado; dor costas/pernas leve; cansaco moderado => risco pouco provavel
ativa_regra38 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra38 = np.fmin(ativa_regra38, risco_poucoprovavel) #implicacao
if regra38.any() != 0:
regras_ativas.append(38)
#Regra 39: dismenorreia moderado; dispareunia moderado; dor costas/pernas leve; cansaco intenso => risco provavel
ativa_regra39 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra39 = np.fmin(ativa_regra39, risco_provavel) #implicacao
if regra39.any() != 0:
regras_ativas.append(39)
#Regra 40: dismenorreia moderado; dispareunia moderado; dor costas/pernas moderado; cansaco leve => risco improvavel
ativa_regra40 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra40 = np.fmin(ativa_regra40, risco_improvavel) #implicacao
if regra40.any() != 0:
regras_ativas.append(40)
#Regra 41: dismenorreia moderado; dispareunia moderado; dor costas/pernas moderado; cansaco moderado => risco pouco provavel
ativa_regra41 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra41 = np.fmin(ativa_regra41, risco_poucoprovavel) #implicacao
if regra41.any() != 0:
regras_ativas.append(41)
#Regra 42: dismenorreia moderado; dispareunia moderado; dor costas/pernas moderado; cansaco intenso => risco provavel
ativa_regra42 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra42 = np.fmin(ativa_regra42, risco_provavel) #implicacao
if regra42.any() != 0:
regras_ativas.append(42)
#Regra 43: dismenorreia moderado; dispareunia moderado; dor costas/pernas intenso; cansaco leve => risco provavel
ativa_regra43 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra43 = np.fmin(ativa_regra43, risco_provavel) #implicacao
if regra43.any() != 0:
regras_ativas.append(43)
#Regra 44: dismenorreia moderado; dispareunia moderado; dor costas/pernas intenso; cansaco moderado => risco provavel
ativa_regra44 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra44 = np.fmin(ativa_regra44, risco_provavel) #implicacao
if regra44.any() != 0:
regras_ativas.append(44)
#Regra 45: dismenorreia moderado; dispareunia moderado; dor costas/pernas intenso; cansaco intenso => risco muito provavel
ativa_regra45 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra45 = np.fmin(ativa_regra45, risco_muitoprovavel) #implicacao
if regra45.any() != 0:
regras_ativas.append(45)
#Regra 46: dismenorreia moderado; dispareunia intenso; dor costas/pernas leve; cansaco leve => risco pouco provavel
ativa_regra46 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra46 = np.fmin(ativa_regra46, risco_poucoprovavel) #implicacao
if regra46.any() != 0:
regras_ativas.append(46)
#Regra 47: dismenorreia moderado; dispareunia intenso; dor costas/pernas leve; cansaco moderado => risco provavel
ativa_regra47 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra47 = np.fmin(ativa_regra47, risco_provavel) #implicacao
if regra47.any() != 0:
regras_ativas.append(47)
#Regra 48: dismenorreia moderado; dispareunia intenso; dor costas/pernas leve; cansaco intenso => risco provavel
ativa_regra48 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra48 = np.fmin(ativa_regra48, risco_provavel) #implicacao
if regra48.any() != 0:
regras_ativas.append(48)
#Regra 49: dismenorreia moderado; dispareunia intenso; dor costas/pernas moderado; cansaco leve => risco provavel
ativa_regra49 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra49 = np.fmin(ativa_regra49, risco_provavel) #implicacao
if regra49.any() != 0:
regras_ativas.append(49)
#Regra 50: dismenorreia moderado; dispareunia intenso; dor costas/pernas moderado; cansaco moderado => risco provavel
ativa_regra50 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra50 = np.fmin(ativa_regra50, risco_provavel) #implicacao
if regra50.any() != 0:
regras_ativas.append(50)
#Regra 51: dismenorreia moderado; dispareunia intenso; dor costas/pernas moderado; cansaco intenso => risco muito provavel
ativa_regra51 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra51 = np.fmin(ativa_regra51, risco_muitoprovavel) #implicacao
if regra51.any() != 0:
regras_ativas.append(51)
#Regra 52: dismenorreia moderado; dispareunia intenso; dor costas/pernas intenso; cansaco leve => risco provavel
ativa_regra52 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra52 = np.fmin(ativa_regra52, risco_provavel) #implicacao
if regra52.any() != 0:
regras_ativas.append(52)
#Regra 53: dismenorreia moderado; dispareunia intenso; dor costas/pernas intenso; cansaco moderado => risco muito provavel
ativa_regra53 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra53 = np.fmin(ativa_regra53, risco_muitoprovavel) #implicacao
if regra53.any() != 0:
regras_ativas.append(53)
#Regra 54: dismenorreia moderado; dispareunia intenso; dor costas/pernas intenso; cansaco intenso => risco muito provavel
ativa_regra54 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_moderada, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra54 = np.fmin(ativa_regra54, risco_muitoprovavel) #implicacao
if regra54.any() != 0:
regras_ativas.append(54)
#Regra 55: dismenorreia intenso; dispareunia leve; dor costas/pernas leve; cansaco leve => risco improvavel
ativa_regra55 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra55 = np.fmin(ativa_regra55, risco_improvavel) #implicacao
if regra55.any() != 0:
regras_ativas.append(55)
#Regra 56: dismenorreia intenso; dispareunia leve; dor costas/pernas leve; cansaco moderado => risco improvavel
ativa_regra56 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra56 = np.fmin(ativa_regra56, risco_improvavel) #implicacao
if regra56.any() != 0:
regras_ativas.append(56)
#Regra 57: dismenorreia intenso; dispareunia leve; dor costas/pernas leve; cansaco intenso => risco pouco provavel
ativa_regra57 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra57 = np.fmin(ativa_regra57, risco_poucoprovavel) #implicacao
if regra57.any() != 0:
regras_ativas.append(57)
#Regra 58: dismenorreia intenso; dispareunia leve; dor costas/pernas moderado; cansaco leve => risco pouco provavel
ativa_regra58 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra58 = np.fmin(ativa_regra58, risco_poucoprovavel) #implicacao
if regra58.any() != 0:
regras_ativas.append(58)
#Regra 59: dismenorreia intenso; dispareunia leve; dor costas/pernas moderado; cansaco moderado => risco pouco provavel
ativa_regra59 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra59 = np.fmin(ativa_regra59, risco_poucoprovavel) #implicacao
if regra59.any() != 0:
regras_ativas.append(59)
#Regra 60: dismenorreia intenso; dispareunia leve; dor costas/pernas moderado; cansaco intenso => risco provavel
ativa_regra60 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra60 = np.fmin(ativa_regra60, risco_provavel) #implicacao
if regra60.any() != 0:
regras_ativas.append(60)
#Regra 61: dismenorreia intenso; dispareunia leve; dor costas/pernas intenso; cansaco leve => risco pouco provavel
ativa_regra61 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra61 = np.fmin(ativa_regra61, risco_poucoprovavel) #implicacao
if regra61.any() != 0:
regras_ativas.append(61)
#Regra 62: dismenorreia intenso; dispareunia leve; dor costas/pernas intenso; cansaco moderado => risco provavel
ativa_regra62 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra62 = np.fmin(ativa_regra62, risco_provavel) #implicacao
if regra62.any() != 0:
regras_ativas.append(62)
#Regra 63: dismenorreia intenso; dispareunia leve; dor costas/pernas intenso; cansaco intenso => risco muito provavel
ativa_regra63 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_leve))) #composicao usando operador AND (minimo)
regra63 = np.fmin(ativa_regra63, risco_muitoprovavel) #implicacao
if regra63.any() != 0:
regras_ativas.append(63)
#Regra 64: dismenorreia intenso; dispareunia moderado; dor costas/pernas leve; cansaco leve => risco pouco provavel
ativa_regra64 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra64 = np.fmin(ativa_regra64, risco_poucoprovavel) #implicacao
if regra64.any() != 0:
regras_ativas.append(64)
#Regra 65: dismenorreia intenso; dispareunia moderado; dor costas/pernas leve; cansaco moderado => risco pouco provavel
ativa_regra65 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra65 = np.fmin(ativa_regra65, risco_poucoprovavel) #implicacao
if regra65.any() != 0:
regras_ativas.append(65)
#Regra 66: dismenorreia intenso; dispareunia moderado; dor costas/pernas leve; cansaco intenso => risco provavel
ativa_regra66 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra66 = np.fmin(ativa_regra66, risco_provavel) #implicacao
if regra66.any() != 0:
regras_ativas.append(66)
#Regra 67: dismenorreia intenso; dispareunia moderado; dor costas/pernas moderado; cansaco leve => risco pouco provavel
ativa_regra67 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra67 = np.fmin(ativa_regra67, risco_poucoprovavel) #implicacao
if regra67.any() != 0:
regras_ativas.append(67)
#Regra 68: dismenorreia intenso; dispareunia moderado; dor costas/pernas moderado; cansaco moderado => risco provavel
ativa_regra68 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra68 = np.fmin(ativa_regra68, risco_provavel) #implicacao
if regra68.any() != 0:
regras_ativas.append(68)
#Regra 69: dismenorreia intenso; dispareunia moderado; dor costas/pernas moderado; cansaco intenso => risco provavel
ativa_regra69 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra69 = np.fmin(ativa_regra69, risco_provavel) #implicacao
if regra69.any() != 0:
regras_ativas.append(69)
#Regra 70: dismenorreia intenso; dispareunia moderado; dor costas/pernas intenso; cansaco leve => risco provavel
ativa_regra70 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra70 = np.fmin(ativa_regra70, risco_provavel) #implicacao
if regra70.any() != 0:
regras_ativas.append(70)
#Regra 71: dismenorreia intenso; dispareunia moderado; dor costas/pernas intenso; cansaco moderado => risco provavel
ativa_regra71 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra71 = np.fmin(ativa_regra71, risco_provavel) #implicacao
if regra71.any() != 0:
regras_ativas.append(71)
#Regra 72: dismenorreia intenso; dispareunia moderado; dor costas/pernas intenso; cansaco intenso => risco muito provavel
ativa_regra72 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_moderada))) #composicao usando operador AND (minimo)
regra72 = np.fmin(ativa_regra72, risco_muitoprovavel) #implicacao
if regra72.any() != 0:
regras_ativas.append(72)
#Regra 73: dismenorreia intenso; dispareunia intenso; dor costas/pernas leve; cansaco leve => risco pouco provavel
ativa_regra73 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra73 = np.fmin(ativa_regra73, risco_poucoprovavel) #implicacao
if regra73.any() != 0:
regras_ativas.append(73)
#Regra 74: dismenorreia intenso; dispareunia intenso; dor costas/pernas leve; cansaco moderado => risco provavel
ativa_regra74 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra74 = np.fmin(ativa_regra74, risco_provavel) #implicacao
if regra74.any() != 0:
regras_ativas.append(74)
#Regra 75: dismenorreia intenso; dispareunia intenso; dor costas/pernas leve; cansaco intenso => risco muito provavel
ativa_regra75 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_leve, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra75 = np.fmin(ativa_regra75, risco_muitoprovavel) #implicacao
if regra75.any() != 0:
regras_ativas.append(75)
#Regra 76: dismenorreia intenso; dispareunia intenso; dor costas/pernas moderado; cansaco leve => risco provavel
ativa_regra76 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra76 = np.fmin(ativa_regra76, risco_provavel) #implicacao
if regra76.any() != 0:
regras_ativas.append(76)
#Regra 77: dismenorreia intenso; dispareunia intenso; dor costas/pernas moderado; cansaco moderado => risco provavel
ativa_regra77 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra77 = np.fmin(ativa_regra77, risco_provavel) #implicacao
if regra77.any() != 0:
regras_ativas.append(77)
#Regra 78: dismenorreia intenso; dispareunia intenso; dor costas/pernas moderado; cansaco intenso => risco muito provavel
ativa_regra78 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_moderada, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra78 = np.fmin(ativa_regra78, risco_muitoprovavel) #implicacao
if regra78.any() != 0:
regras_ativas.append(78)
#Regra 79: dismenorreia intenso; dispareunia intenso; dor costas/pernas intenso; cansaco leve => risco muito provavel
ativa_regra79 = np.fmin(cansaco_nivel_leve, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra79 = np.fmin(ativa_regra79, risco_muitoprovavel) #implicacao
if regra79.any() != 0:
regras_ativas.append(79)
#Regra 80: dismenorreia intenso; dispareunia intenso; dor costas/pernas intenso; cansaco moderado => risco muito provavel
ativa_regra80 = np.fmin(cansaco_nivel_moderado, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra80 = np.fmin(ativa_regra80, risco_muitoprovavel) #implicacao
if regra80.any() != 0:
regras_ativas.append(80)
#Regra 81: dismenorreia intenso; dispareunia intenso; dor costas/pernas intenso; cansaco intenso => risco muito provavel
ativa_regra81 = np.fmin(cansaco_nivel_intenso, np.fmin(dorCP_nivel_intensa, np.fmin(dismenorreia_nivel_intensa, dispareunia_nivel_intensa))) #composicao usando operador AND (minimo)
regra81 = np.fmin(ativa_regra81, risco_muitoprovavel) #implicacao
if regra81.any() != 0:
regras_ativas.append(81)
print "regras ativas: "+str(regras_ativas)
## Agregacao das regras
agregacao = np.fmax(regra81,
np.fmax(regra80,
np.fmax(regra79,
np.fmax(regra78,
np.fmax(regra77,
np.fmax(regra76,
np.fmax(regra75,
np.fmax(regra74,
np.fmax(regra73,
np.fmax(regra72,
np.fmax(regra71,
np.fmax(regra70,
np.fmax(regra69,
np.fmax(regra68,
np.fmax(regra67,
np.fmax(regra66,
np.fmax(regra65,
np.fmax(regra64,
np.fmax(regra63,
np.fmax(regra62,
np.fmax(regra61,
np.fmax(regra60,
np.fmax(regra59,
np.fmax(regra58,
np.fmax(regra57,
np.fmax(regra56,
np.fmax(regra55,
np.fmax(regra54,
np.fmax(regra53,
np.fmax(regra52,
np.fmax(regra51,
np.fmax(regra50,
np.fmax(regra49,
np.fmax(regra48,
np.fmax(regra47,
np.fmax(regra46,
np.fmax(regra45,
np.fmax(regra44,
np.fmax(regra43,
np.fmax(regra42,
np.fmax(regra41,
np.fmax(regra40,
np.fmax(regra39,
np.fmax(regra38,
np.fmax(regra37,
np.fmax(regra36,
np.fmax(regra35,
np.fmax(regra34,
np.fmax(regra33,
np.fmax(regra32,
np.fmax(regra31,
np.fmax(regra30,
np.fmax(regra29,
np.fmax(regra28,
np.fmax(regra27,
np.fmax(regra26,
np.fmax(regra25,
np.fmax(regra24,
np.fmax(regra23,
np.fmax(regra22,
np.fmax(regra21,
np.fmax(regra20,
np.fmax(regra19,
np.fmax(regra18,
np.fmax(regra17,
np.fmax(regra16,
np.fmax(regra15,
np.fmax(regra14,
np.fmax(regra13,
np.fmax(regra12,
np.fmax(regra11,
np.fmax(regra10,
np.fmax(regra9,
np.fmax(regra8,
np.fmax(regra7,
np.fmax(regra6,
np.fmax(regra5,
np.fmax(regra4,
np.fmax(regra3,
np.fmax(regra1, regra2)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) #agregacao das regras
risco0 = np.zeros_like(risco) #variavel auxiliar para montar o grafico
## Calculo do resultado defuzzificado
risco_def = fuzz.defuzz(risco, agregacao, 'centroid') #defuzzificacao pelo metodo centroide
risco_ativacao = fuzz.interp_membership(risco, agregacao, risco_def) #intersecao do risco defuzzificado com a funcao de pertinencia
## Grafico da funcao de pertinencia resultante
fig, ax0 = plt.subplots(figsize=(9.27,3.23))
ax0.plot(risco, risco_improvavel, 'b', linewidth=0.5, label='I', linestyle='--')
ax0.plot(risco, risco_poucoprovavel, 'g', linewidth=0.5, label='PP', linestyle='--')
ax0.plot(risco, risco_provavel, 'y', linewidth=0.5, label='P', linestyle='--')
ax0.plot(risco, risco_muitoprovavel, 'r', linewidth=1.5, label='MP', linestyle='--')
ax0.legend(loc='upper center',bbox_to_anchor=(0.5, 1.05), ncol=4, fancybox=True, shadow=True)
ax0.fill_between(risco, risco0, agregacao, facecolor='Orange', alpha=0.7)
ax0.plot([risco_def, risco_def], [0, risco_ativacao], 'k', linewidth=1.5, alpha=0.9)
plt.xticks(np.append(plt.xticks()[0],risco_def))
plt.xlabel('risco (%)')
ax0.set_title("Agregacao das regras e resultado defuzzificado")
plt.tight_layout()
plt.show()
return risco_def
def fuzzylabels(ts, alts, spds, rocs, twindow=60):
'''
Fuzzy logic to determine the segments of the flight data
segments are: ground [GND], climb [CL], descent [DE], cruise [CR].
Default time window is 60 second.
'''
if len(set([len(ts), len(alts), len(spds), len(rocs)])) > 1:
raise RuntimeError('input ts and alts must have same length')
n = len(ts)
ts = np.array(ts)
ts = ts - ts[0]
idxs = np.arange(0, n)
alts = UnivariateSpline(ts, alts)(ts)
spds = UnivariateSpline(ts, spds)(ts)
rocs = UnivariateSpline(ts, rocs)(ts)
labels = ['NA'] * n
twindows = ts // twindow
print
for tw in range(0, int(max(twindows))):
if tw not in twindows:
continue
mask = (twindows == tw)
idxchk = idxs[mask]
tchk = ts[mask]
altchk = alts[mask]
spdchk = spds[mask]
rocchk = rocs[mask]
# mean value or extream value as range
alt = max(min(np.mean(altchk), alt_range[-1]), alt_range[0])
spd = max(min(np.mean(spdchk), spd_range[-1]), spd_range[0])
roc = max(min(np.mean(rocchk), roc_range[-1]), roc_range[0])
# make sure values are within the boundaries
alt = max(min(alt, alt_range[-1]), alt_range[0])
spd = max(min(spd, spd_range[-1]), spd_range[0])
roc = max(min(roc, roc_range[-1]), roc_range[0])
alt_level_gnd = fuzz.interp_membership(alt_range, alt_gnd, alt)
alt_level_lo = fuzz.interp_membership(alt_range, alt_lo, alt)
alt_level_hi = fuzz.interp_membership(alt_range, alt_hi, alt)
spd_level_hi = fuzz.interp_membership(spd_range, spd_hi, spd)
spd_level_md = fuzz.interp_membership(spd_range, spd_md, spd)
spd_level_lo = fuzz.interp_membership(spd_range, spd_lo, spd)
roc_level_zero = fuzz.interp_membership(roc_range, roc_zero, roc)
roc_level_plus = fuzz.interp_membership(roc_range, roc_plus, roc)
roc_level_minus = fuzz.interp_membership(roc_range, roc_minus, roc)
# print alt_level_gnd, alt_level_lo, alt_level_hi
# print roc_level_zero, roc_level_plus, roc_level_minus
# print spd_level_hi, spd_level_md, spd_level_lo
rule_ground = min(alt_level_gnd, roc_level_zero, spd_level_lo)
state_activate_ground = np.fmin(rule_ground, state_ground)
rule_climb = min(alt_level_lo, roc_level_plus, spd_level_md)
state_activate_climb = np.fmin(rule_climb, state_climb)
rule_descent = min(alt_level_lo, roc_level_minus, spd_level_md)
state_activate_descent = np.fmin(rule_descent, state_descent)
rule_cruise = min(alt_level_hi, roc_level_zero, spd_level_hi)
state_activate_cruise = np.fmin(rule_cruise, state_cruise)
rule_level = min(alt_level_lo, roc_level_zero, spd_level_md)
state_activate_level = np.fmin(rule_level, state_level)
aggregated = np.max(
np.vstack([
state_activate_ground,
state_activate_climb,
state_activate_descent,
state_activate_cruise,
state_activate_level,
]), axis=0
)
state_raw = fuzz.defuzz(states, aggregated, 'lom')
state = int(round(state_raw))
if state > 6:
state = 6
if state < 1:
state = 1
label = state_lable_map[state]
labels[idxchk[0]:idxchk[-1]] = [label] * len(idxchk)
# labels[i] = label
return labels
