Respostas no Fórum
- Posts
Olá Luna, espero que esteja bem.
Sim! Você conseguirá fazer aplicações práticas sim. Meu conselho é que você dê atenção especial para a parte do hardfuzzy. Com essa abordagem você consegue abrir as possibilidades de aplicações e seus projetos ganham profissionalismo.
Espero ter ajudado.
Prof. Eduardo A. Franciscon
Olá Bruno,
Muito bem observado! Continue seus cálculos levando em consideração 5,5.
Bom trabalho!
Prof. Eduardo A. Franciscon
Olá Bruno, espero que esteja bem.
Vamos lá!
Como você calculou a base para que chegasse em 5,5?
Baseado nisso vamos conferir juntos o resultado que você apontou.
Prof. Eduardo A. Franciscon
Bom dia Alexandre, imagino que já resolvido sua dúvida. Conversamos por outro canal.
Fico a disposição!
Atte.
Olá Alexandre, espero que esteja bem!
Imagino que esteja falando das variáveis de antecedentes e consequentes. Para uma construção de lógica, você pode sim variar o número de variáveis, mas, cuidado, em sua construção de regras, elas precisam estar bem elaboradas e “amarradas”, para que a sua “defuzzificação” venha com resultados relevantes.
Espero ter ajudado.
Prof. Eduardo A. Franciscon
Atte
bom dia Ronald,
Segue em código aqui um exemplo. Não tenho a opção de anexar arquivo pra você.
#installs
pip install -U scikit-fuzzy#imports
import numpy as np
import skfuzzy as fuzz
import matplotlib.pyplot as plt# Gerarando as variáveis do problema
# * varáveis de Qualidade e serviço em faixas de [0, 10]
# * a variável “x_tip” que traz o resultado com um intervalo de [0, 25]. Em unidades de pontos percentuais.
x_qual = np.arange(0, 11, 1)
x_serv = np.arange(0, 11, 1)
x_tip = np.arange(0, 26, 1)# Gera as variáveis para as funções de associação difusas
qual_lo = fuzz.trimf(x_qual, [0, 0, 5])
qual_md = fuzz.trimf(x_qual, [0, 5, 10])
qual_hi = fuzz.trimf(x_qual, [5, 10, 10])
serv_lo = fuzz.trimf(x_serv, [0, 0, 5])
serv_md = fuzz.trimf(x_serv, [0, 5, 10])
serv_hi = fuzz.trimf(x_serv, [5, 10, 10])
tip_lo = fuzz.trimf(x_tip, [0, 0, 13])
tip_md = fuzz.trimf(x_tip, [0, 13, 25])
tip_hi = fuzz.trimf(x_tip, [13, 25, 25])# Interliga as variáveis para a criação das funções de associação do problema.
#Cria o ambiente gráfico onde será cruzado os valores para a defuzzificação.
fig, (ax0, ax1, ax2) = plt.subplots(nrows=3, figsize=(8, 9))ax0.plot(x_qual, qual_lo, ‘b’, linewidth=1.5, label=’Mau’)
ax0.plot(x_qual, qual_md, ‘g’, linewidth=1.5, label=’Decente’)
ax0.plot(x_qual, qual_hi, ‘r’, linewidth=1.5, label=’Ótimo’)
ax0.set_title(‘Qualidade da comida’)
ax0.legend()ax1.plot(x_serv, serv_lo, ‘b’, linewidth=1.5, label=’Pobre’)
ax1.plot(x_serv, serv_md, ‘g’, linewidth=1.5, label=’Aceitável’)
ax1.plot(x_serv, serv_hi, ‘r’, linewidth=1.5, label=’Surpreendente’)
ax1.set_title(‘Qualidade do serviço’)
ax1.legend()ax2.plot(x_tip, tip_lo, ‘b’, linewidth=1.5, label=’Baixo’)
ax2.plot(x_tip, tip_md, ‘g’, linewidth=1.5, label=’Medio’)
ax2.plot(x_tip, tip_hi, ‘r’, linewidth=1.5, label=’Alto’)
ax2.set_title(‘Valor de gorjeta’)
ax2.legend()# Desliga os eixos superior/direito
for ax in (ax0, ax1, ax2):
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()
(
Regras difusas
Agora, para tornar essa triângulação gráfica útil, definimos a relação difusa entre as variáveis de entrada e saída. Em nosso exemplo, considere três regras simples:
Se a comida for ruim OU o serviço for ruim, a gorjeta será baixa
Se o serviço for aceitável, a gorjeta será média
Se a comida for ótima OU o serviço for incrível, a gorjeta será alta.)
# Aqui configuramos as funções de associação difusa nos valores escolhidos:
# (Nesse caso) Os valores 8.0 (qualidade) e 6.5 (serviço).
# Para isso se utiliza o “fuzz.interp_membership”.qual_level_lo = fuzz.interp_membership(x_qual, qual_lo, 8.0)
qual_level_md = fuzz.interp_membership(x_qual, qual_md, 8.0)
qual_level_hi = fuzz.interp_membership(x_qual, qual_hi, 8.0)serv_level_lo = fuzz.interp_membership(x_serv, serv_lo, 6.5)
serv_level_md = fuzz.interp_membership(x_serv, serv_md, 6.5)
serv_level_hi = fuzz.interp_membership(x_serv, serv_hi, 6.5)# Agora se aplica as regras.
#Regra 1: diz respeito a comida OU serviço ruim.
active_rule1 = np.fmax(qual_level_lo, serv_level_lo)# função de associação “np.fmin” elimina o topo da saída correspondente. Removendo inteiramento para 0.
tip_activation_lo = np.fmin(active_rule1, tip_lo)# Regra 2, se conecta serviço aceitável à gorjeta média.
tip_activation_md = np.fmin(serv_level_md, tip_md)#Regra 3, se conecta serviço Surpreendente OU Ótima comida com alta gorjeta.
active_rule3 = np.fmax(qual_level_hi, serv_level_hi)
tip_activation_hi = np.fmin(active_rule3, tip_hi)
tip0 = np.zeros_like(x_tip)#Visualizando após a construção das regras
fig, ax0 = plt.subplots(figsize=(8, 3))ax0.fill_between(x_tip, tip0, tip_activation_lo, facecolor=’b’, alpha=0.7)
ax0.plot(x_tip, tip_lo, ‘b’, linewidth=0.5, linestyle=’–‘, )
ax0.fill_between(x_tip, tip0, tip_activation_md, facecolor=’g’, alpha=0.7)
ax0.plot(x_tip, tip_md, ‘g’, linewidth=0.5, linestyle=’–‘)
ax0.fill_between(x_tip, tip0, tip_activation_hi, facecolor=’r’, alpha=0.7)
ax0.plot(x_tip, tip_hi, ‘r’, linewidth=0.5, linestyle=’–‘)
ax0.set_title(‘Saída das atividades interligadas’)# Desliga os eixos superior/direito
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()
(
Agregação da Regra
Com a atividade de cada função de associação de saída conhecida, todas as funções de associação de saída devem ser combinadas.
Defuzzificação
Esse método é importante, pois ele estabelece um retorno ao usuário, que se encaixa na lógica anteriormente configurada. Porém o retorno vem de forma única e exata, depois de já ter tratado a questão da difusão. Ou seja, na perspectiva fuzzy que a comida % meio boa e % meio ruim. Em uma escala de 1-10. A comida está com 6.9 exatos de qualidade. E com isso definimos um valor de gorjeta!
A defuzzificação pode ser calculada com fórmulas diferentes, sendo elas:
centroid (centroid)
bisector (bisector)
mean of maximum (mom)
min of maximum (som)
max of maximum (lom))
#Agrega todas as três funções de associação de saída juntas
aggregated = np.fmax(tip_activation_lo, np.fmax(tip_activation_md, tip_activation_hi))# Calcula o resultado da defuzzificação.
tip = fuzz.defuzz(x_tip, aggregated, ‘centroid’)
#tip = fuzz.defuzz(x_tip, aggregated, ‘bisector’)
#tip = fuzz.defuzz(x_tip, aggregated, ‘mom’)
#tip = fuzz.defuzz(x_tip, aggregated, ‘som’)
#tip = fuzz.defuzz(x_tip, aggregated, ‘lom’)
tip_activation = fuzz.interp_membership(x_tip, aggregated, tip)# Visualização após aplicação dos conjuntos e defuzzificação
fig, ax0 = plt.subplots(figsize=(8, 3))ax0.plot(x_tip, tip_lo, ‘b’, linewidth=0.5, linestyle=’–‘, )
ax0.plot(x_tip, tip_md, ‘g’, linewidth=0.5, linestyle=’–‘)
ax0.plot(x_tip, tip_hi, ‘r’, linewidth=0.5, linestyle=’–‘)
ax0.fill_between(x_tip, tip0, aggregated, facecolor=’purple’, alpha=0.7)
ax0.plot([tip, tip], [0, tip_activation], ‘k’, linewidth=1.5, alpha=0.9)
ax0.set_title(‘Resutado agregado após a defuzzificação (LINHA)’)# Desliga os eixos superior/direito
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()
#Visualização do número calculado pela defuzzificação (LINHA)
print(“(Valor gorjeta) (LINHA) – Resultado: “, tip)Boa tarde Rejane, obrigado por compartilhar sua dúvida.
Aproveitando a resposta que dei ao Geraldo:
A função responsável pela defuzzificação é um cálculo interno da biblioteca, e nós não temos acesso a ela. Mas o que sabemos, é que ela calcula o valor de cada área para fazer um valor único que melhor corresponde ao método de defuzzificação escolhido. No entanto, quando definimos no modelo básico de fuzzy, um valor de “qualidade” e “serviço” entre 0 e 10 com as nominações variando de “boa”, “mediana” e “ruim”, temos um valor correspondente a cada opção, e com uma variação de casas decimais, pois é 10/3. E quando o cálculo fuzzy é executado (levando em consideração os valores de input dados pelo usuário), temos essa margem de diferença que você percebeu. Esse é um dos grandes motivos de se ter por perto um especialista no assunto a ser aplicado a lógica fuzzy, pois a seleção de áreas e a construção de regras para mais tarde formar valores reais, necessitam muito de exatidão técnica. E como o exemplo da gorjeta é um exercício simples, apenas para uso didático, temos esse probleminha.
E sobre a interferência de um conjunto de regras, sim, isso interfere também, pois de acordo com a forma que você constrói o mecanismo das regras, o mesmo mudará o resultado da defuzzificação.
Em uma aplicação real, é importante que fique claro a forma que você usará a biblioteca do skfuzzy, pois como é visível na galeria de exemplo (segue o link abaixo), existem diferentes formas de se trabalhar com os antecedentes e consequentes, e essas formas podem resolver esse problema que você percebeu. Também é importante saber que em problemas complexos, um especialista no trabalho a ser aplicado fuzzy, é indispensável, pois ele irá trazer mais clareza e exatidão na construção dos conjuntos de antecedentes e construção de regras, auxiliado também na solução da saturação.
Link skfuzzy: https://pythonhosted.org/scikit-fuzzy/auto_examples/index.html
Para o uso em problemas reais ou complexos é importante que fique claro que as opções simples de código fuzzy podem não ser as melhores escolhas. Em projetos reais, como por exemplo, controladores industriais, a forma de aplicação da lógica fuzzy e forma de implantação do código pode variar, e tudo isso ajuda a melhorar ou tornar ideal a solução do trabalho.
Bom dia Geraldo, obrigado por perguntar!
Para responder sua pergunta, a função responsável pela defuzzificação é um cálculo interno da biblioteca, e nós não temos acesso a ela. Mas o que sabemos, é que ela calcula o valor de cada área para fazer um valor único que melhor corresponde ao método de defuzzificação escolhido. No entanto, quando definimos no modelo básico de fuzzy, um valor de “qualidade” e “serviço” entre 0 e 10 com as nominações variando de “boa”, “mediana” e “ruim”, temos um valor correspondente a cada opção, e com uma variação de casas decimais, pois é 10/3. E quando o cálculo fuzzy é executado (levando em consideração os valores de input dados pelo usuário), temos essa margem de diferença que você percebeu. Esse é um dos grandes motivos de se ter por perto um especialista no assunto a ser aplicado a lógica fuzzy, pois a seleção de áreas e a construção de regras para mais tarde formar valores reais, necessitam muito de exatidão técnica. E como o exemplo da gorjeta é um exercício simples, apenas para uso didático, temos esse probleminha.
Espero ter ajudado!
Bons estudos!
Bom dia Iran Charles, espero que esteja bem! desculpa pela demora em responder.
A divisão dos grupos vem de forma automática pela funcionalidade dos algoritmos implementados dentro da biblioteca, tanto o cmens, quanto o cmens_predict formam um centro(o ponto de referência) e trabalham a clusterização de acordo com isso. Tudo no automático.
Porém, dependendo de sua forma de tratar esses dados ou do seu problema, aconselho a verificar técnicas de associação ou classificação, existem abordagens dentro da data mining que pode lhe ajudar, com mais facilidade que está do cmeans.
Segue o link da documentação que lhe citei acima:
https://scikit-fuzzy.readthedocs.io/en/latest/api/skfuzzy.html#cmeans
Obrigado por perguntar e passe bem!
Abraço!
