Análise de Motores de Regras

SmartMail| Entidade Promotora:
Parceiros:
22/04/2014
Motores de Regras
1/2
Projeto em curso com o apoio de:
Parceiros:
ndice
ndice de Figuras.............................................................................................................................. 2
ndice de Tabelas ............................................................................................................................. 4
Introduo ....................................................................................................................................... 5
Modelos de Regras .......................................................................................................................... 6
Motores de Regras .......................................................................................................................... 8
Aproximaes dos motores de regras......................................................................................... 9
Forward Chaining .................................................................................................................... 9
Backward Chaining ................................................................................................................ 10
Lgica Difusa.......................................................................................................................... 12
Sistemas de motores de Regras Crisp ........................................................................................... 16
Jess ............................................................................................................................................ 16
Experimentao Prtica ........................................................................................................ 17
JBoss/Drools .............................................................................................................................. 21
Experimentao prtica ........................................................................................................ 22
Drools.NET ................................................................................................................................. 27
Prolog ........................................................................................................................................ 27
Variantes ............................................................................................................................... 31
Sistemas de motores de Regras Fuzzy .......................................................................................... 33
Fuzzy Jess ................................................................................................................................... 33
FuzzyCLIPS ................................................................................................................................. 38
fuzzyTECH .................................................................................................................................. 47
Experimentao prtica ........................................................................................................ 47
jFuzzyLogic ................................................................................................................................. 58
2/2
Parceiros:
ndice de Figuras
Figura 1: Distribuio de um termo difuso ................................................................................... 14
Figura 2: Termo difuso com aplicao de modificador ................................................................. 15
Figura 3: Consola do Jess pronta a receber comandos ................................................................. 17
Figura 4: Declarao de Variveis Locais....................................................................................... 18
Figura 5: Declarao de varivel Global ........................................................................................ 18
Figura 6: Criao visual de regras .................................................................................................. 22
Figura 7: Exemplo mais complexo de uma regra criada visualmente .......................................... 23
Figura 8: Tabela de Deciso........................................................................................................... 24
Figura 9: Regras geradas automaticamente da tabela de deciso ............................................... 25
Figura 10: Exemplo de tabela expandida ...................................................................................... 25
Figura 11: Alterao das regras por matriz ................................................................................... 26
Figura 12: Aspeto da consola do SWI-Prolog ................................................................................ 29
Figura 13: Grfico com os intervalos definidos ............................................................................. 35
Figura 14: Grfico resultante da query ......................................................................................... 35
Figura 15: Intervalo em forma de triangulo .................................................................................. 36
Figura 16: Intervalo difuso irregular.............................................................................................. 37
Figura 17: Interseo de Intervalos ............................................................................................... 37
Figura 18: Unio de Intervalos ...................................................................................................... 37
Figura 19: Grfico do intervalo difuso para young .................................................................... 39
Figura 20: Intervalo linear ............................................................................................................. 42
Figura 21: Grficos das funes S, Z e PI ....................................................................................... 43
Figura 22: Intervalo onde sero aplicados os modificadores ....................................................... 44
Figura 23: Modificador Not ........................................................................................................... 44
Figura 24: Modificador Very .......................................................................................................... 44
Figura 25: Modificador More-or-Less ........................................................................................... 45
Figura 26: Modificador Somewhat ................................................................................................ 45
Figura 27: Modificador Slightly ..................................................................................................... 45
Figura 28: Modificador Intensity ................................................................................................... 45
Figura 29: Modificador de Normalizao ...................................................................................... 45
Figura 30: Modificador Extremely ................................................................................................. 45
Figura 31: Projeto vazio ................................................................................................................. 48
Figura 32: Wizard de projeto simples ........................................................................................... 49
Figura 33: Tipo de projeto e nmero de variveis ........................................................................ 49
2/2
Parceiros:
Figura 34: Definio das variveis e do formato de sada ............................................................ 50

Figura 35: Definio dos blocos de regras .................................................................................... 50
Figura 36: Diagrama obtido ........................................................................................................... 51
Figura 37: Mapeamento da varivel difusa 1 ................................................................................ 51
Figura 38: Alterao de um ponto do termo Medium .................................................................. 52
Figura 39: Tabela de regras ........................................................................................................... 52
Figura 40: Mapeamento da varivel difusa de saida .................................................................... 53
Figura 41: Diagrama de controlo de grua ..................................................................................... 53
Figura 42: Termos e intervalos difusos do angulo e distncia da grua ......................................... 54
Figura 43:Tabela de regras entre distncia, angulo e fora do motor .......................................... 54
Figura 44: Simulao das regras fuzzy........................................................................................... 55
Figura 45: Painel de Debug............................................................................................................ 55
Figura 46: Visualizao bidimensional das variveis de entrada e de sada ................................. 56
Figura 47: Visualizao tridimensional das variveis de entrada e de sada ................................ 56
Figura 48: Animao em tempo real com todas as variveis difusas ........................................... 57
Figura 49: Diagrama de controlo com diversas variveis e blocos de regras ............................... 57
Figura 50: Servlets com variveis difusas ...................................................................................... 59
2/2
Parceiros:
ndice de Tabelas
Tabela 1: Distribuio de dois termos difusos .............................................................................. 13
Tabela 2: Exemplo de tabela de regras ......................................................................................... 24
Tabela 3: Modificadores do FuzzyCLIPS ........................................................................................ 43
2/2
Parceiros:
Introduo
O presente documento do projecto QREN Smart Mail est enquadrado na sua Actividade 3 Linha de investigao 3 - Modelos de regras evolutivos. Atravs deste documento pretendese efetuar um levantamento do estado da arte das principais tcnicas e abordagens no domnio
dos motores e modelos de regras, assim como de plataformas e / ou frameworks j existentes
que possam servir de guia e de exemplo com as melhores aproximaes e abordagens na rea.
O objetivo de apreender tal conhecimento e metodologias prende-se com o prprio conceito
do projeto Smart Mail, onde se pretende integrar esses mecanismos no contexto do email, de
forma a incrementar a produtividade, eficincia e inteligncia no modo como o email
utilizado como ferramenta empresarial do dia-a-dia.
O documento ter como estrutura a presente Introduo, seguida de uma anlise genrica e
introdutria aos Modelos de Regras. De seguida, ser apresentada uma anlise ao
funcionamento e s abordagens seguidas pelos Motores de Regras seleccionados para anlise.
Por fim, ser efetuado um levantamento e experimentao dos principais motores de regras e
ferramentas a eles associados.
2/2
Parceiros:
Modelos de Regras
De acordo com a atualidade tecnolgica, os requisitos de flexibilidade e adaptabilidade que os
sistemas informticos esto sujeitos, so cada vez maiores. A maior parte dos sistemas
desenvolvidos recorrem a paradigmas de programao convencional, por isso, tm dificuldades
em acompanhar as constantes mudanas de requisitos, ou de se adaptarem s regras reais e
difusas do mundo real. Uma forma de dotar os sistemas com maior flexibilidade pela
incorporao de modelos de regras.
Os modelos de regras permitem resolver problemas complexos de lgica delimitativa de uma
forma rpida, simples e de uma mais fcil manuteno ou reajuste. A utilizao de regras
permite que tcnicos de um determinado domnio, mesmo sem formao informtica, possam
definir e manter a lgica das regras do sistema. Hoje em dia, os sistemas baseados em modelos
de regras so utilizados em diversas reas, como por exemplo, a segurana de redes,
telecomunicaes, deteo de fraudes, comrcio eletrnico, banca, seguros, controlo de
satlites, etc.
Um modelo de regras simplesmente um sistema que usa regras para derivar concluses.
Uma regra pode ser vista como uma instruo ou comando que aplicada a determinada
situao. Regras como Responder ao email, No responder ao email e outras regras deste
tipo so constantemente utilizadas nos mais diversos contextos. Utilizando esta definio muito
geral, pode-se pensar que todos os conhecimentos e contextos podem ser traduzido em regras,
o que no o caso.
Formalmente as regras podem ser representadas por declaraes do tipo if then como nas
linguagens tradicionais de programao (C/C++, Basic, Java, etc). Podemos escrever uma regra
(em pseudo cdigo) sobre o envio de um email, da seguinte forma:
IF Emissor importante E Assunto importante

THEN Responder j ao email
2/2
Parceiros:
claro que Emissor importante e Assunto importante algo bastante subjetivo e que
necessitaria de ser definido com recurso a outras regras / variveis semnticas, introduzindo o
conceito e a necessidade de ter uma rvore de regras encadeadas entre si, criando assim, a
inteligncia do sistema.
A componente IF das regras escritas desta forma normalmente designada por left-hand side
(LHS), predicado ou premissa. J a parte do THEN designa-se por right-hand side (RHS), aes
ou concluses.
O domnio ao qual a regra aplicada toda a informao disponvel na base de conhecimento
do motor de regras.
2/2
Parceiros:
Motores de Regras
A Inteligncia Artificial envolve o estudo das formas do pensamento humano e aplicar esses
comportamentos e abordagens computao. O aparecimento da Inteligncia Artificial
permitiu entender melhor, modelar e resolver problemas no domnio do mundo real. Os vrios
ramos da IA aplicam-se a diversas reas tais como o processamento de linguagem natural,
processamento de viso, robtica, planeamento, mecanismos de aprendizagem e expert
systems (i.e. sistemas periciais em Portugus).
Os expert systems so um exemplo de sucesso da Inteligncia Artificial na resoluo de
problemas complexos que recorrem fortemente a motores de regras. So sistemas que
capturam o conhecimento de peritos humanos (experts) nas suas reas de especialidade e as
replicam tendo como base um conjunto de regras que copiam o comportamento ou decises
humanas.
Estes sistemas so sempre focados numa rea bem definida e especfica de conhecimento, no
sendo desenhados para resolver todos os problemas em geral. Nestes sistemas os factos,
observaes e hipteses so representados/manipulados como regras. Estes sistemas tambm
tm a capacidade de explicarem as suas decises e de como chegaram a uma concluso A,
assim como justificar porque a concluso B foi descartada. Este um aspeto relevante, visto
permitir aos utilizadores relacionarem-se melhor com o sistema e entenderem como funciona.
O bloco central de um expert system o motor de inferncia. Este pode ser baseado em redes
neuronais, algoritmos genticos, motores de regras, etc. A rea dos motores de regras
apresenta-se como bastante interessante no contexto concreto do email, pois a determinao
e aplicao de regras s diferentes mensagens trocadas de forma automtica permite a sua
catalogao e processamento automtico.
A possibilidade de inspeco da rvore de deciso permite a interpretao da lgica pericial
mesmo por parte de utilizadores no tcnicos.
importante distinguir motores de regras de expert systems (i.e. sistemas periciais) visto no
serem a mesma coisa. Os motores de regras por si s no so expert systems, mas podem ser
uma parte destes no papel do motor de inferncia.
2/2
Parceiros:
Aproximaes dos motores de regras

Nesta seco do presente documento sero apresentadas algumas das aproximaes mais
importantes dos motores de regras, fazendo uma anlise e distino em termos de capacidades
e funcionalidades. Inicialmente iro ser apresentados os diferentes mtodos de inferncia
convencional (forward chaining e backward chaining) que podem ser utilizados pelos motores
de regras. De seguida ser apresentado uma abordagem diferente da lgica clssica (i.e. lgica
difusa ou fuzzy logic) que serve para trabalhar com conceitos vagos, imprecisos, ambguos e
no determinsticos.
Forward Chaining
Nesta abordagem o algoritmo de inferncia forward chaining parte de um conjunto de dados

de onde so obtidas algumas concluses com recurso a regras. De forma iterativa essas
concluses so adicionadas ao conjunto de dados iniciais, de onde so inferidas novas
concluses. O processo repete-se iterativamente at se chegar concluso final pretendida.
Na literatura muitas vezes utilizado um mesmo exemplo para representar esta abordagem em
que se pretende determinar a cor do animal Fritz. Nesse exemplo parte-se com os seguintes
dados:
Fritz coaxa
Fritz come moscas
Tweety come moscas
Tweety chilreia
Tweety amarelo
Onde esto definidas as seguintes regras:

1.
2.
3.
4.
If X coaxa e come moscas Then X um sapo.

If X chilrea e canta Then X um canrio
If X um sapo Then X verde
If X um canrio Then X amarelo
2/2
Parceiros:
Desta forma com a abordagem Forward Chaining, partindo dos dados disponveis e com as
regras anteriores possvel num conjunto de passos lgicos chegar a concluso pretendida
sobre qual a cor do Fritz.
Assim a regra 1 aplica-se aos dados:
If Fritz coaxa e come moscas
Obtendo-se a concluso que adicionada aos dados:
Then Fritz um sapo.
Com o enriquecimento dos dados iniciais com a concluso anterior, ento possvel aplicar a
regra 3.
If Fritz um sapo
Concluindo:
Then X verde
Chegando desta forma a concluso que satisfaz o objetivo inicial de determinar a cor de Fritz.
No mtodo de inferncia forward chaining uma regra semelhante a uma declarao if-then de
uma linguagem imperativa (como o C/C++, Basic, Java), no entanto, no utilizada de uma
forma imperativa. Nas linguagens imperativas as declaraes if-then so executadas em uma
ordem definida pelo programador. No algoritmo forward chaining a parte then de uma
declarao if-then executada assim que parte if satisfeita pelos dados inseridos, o que
resulta em uma ordem de execuo menos determinstica que nas linguagens imperativas, isto
porque o motor de regras que decide a ordem pela qual as regras so executadas.
Backward Chaining
Nesta abordagem o processo um pouco invertido em relao ao Forward Changing. Ao invs

de se partir dos dados para concluses intermdias que passam a pertencer a esses dados
2/2
Parceiros:
sucessivamente at concluso final. Aqui, no Backward Chaining parte-se da hiptese e tentase suporta-la com recurso aos dados e s regras existentes.
Tendo como exemplo o mesmo cenrio utilizado na abordagem Forward Chaining, em que se
pretende determinar qual a cor do Fritz. Neste exemplo parte-se com os mesmos dados:
Fritz coaxa
Fritz come moscas
Tweety come moscas
Tweety chilreia
Tweety amarelo
E com as mesmas regras:

1.
2.
3.
4.
If X coaxa e come moscas Then X um sapo.

If X chilrea e canta Then X um canrio
If X um sapo Then X verde
If X um canrio Then X amarelo
No entanto tambm se inicia com a hiptese que se pretende suportar:

O Fritz verde.
Assim o algoritmo comea por identificar as regras que concluam e suportem (ou refutem) a
hiptese, nomeadamente as concluses das regras 3 e 4:
Then Fritz verde
Then Fritz amarelo
Neste ponto seria gerada uma rvore de deciso, onde a continuao do processo seguiria
independentemente por cada regra at determinar a qual ter sucesso. Aqui a ttulo de
exemplo ir-se- expandir apenas o primeiro caso.
Ainda da regra 3, para esta se confirmar tem de ser cumprida a seguinte premissa:
2/2
Parceiros:
If Fritz um sapo
Para esta premissa ser cumprida o sistema ir procurar outras regras que a suportem. Havendo
uma equivalncia da premissa da regra 3) com a concluso da regra 1). Dessa forma o sistema
salta para a concluso da regra 1):
Then Fritz um sapo
As premissas dessa concluso so:
If Fritz coaxa e come moscas
Que j no necessitam de ser suportadas por outras regras, pois so diretamente suportadas
pelos dados disponveis. Dessa forma, a cadeia de hipteses/premissas fica terminada e
constatada a premissa inicial que o Fritz verde.
Alguns sistemas baseados em regras, especialmente o Prolog e seus derivados, suportam

backward chaining. Um sistema backward chaining orientado ao objetivo (comeando com
uma concluso que o motor de regras tenta satisfazer). Num sistema deste tipo, as regras so
tambm declarao if-then, mas neste caso o motor tenta ativamente chegar ao objetivo de
uma regra (parte then). Se a parte if de uma regra apenas for parcialmente cumprida, o motor
poder concluir que provar o objetivo de uma outra regra (sub objectivo) poder fazer com que
a primeira regra seja totalmente cumprida, caso conclua isto, este vai tentar chegar ao objetivo
da segunda regra, podendo esta ter os seus prprios sub objetivos (sub goals). Este processo
continua at que o objetivo inicial seja comprovado, ou no existam mais sub objetivos,
concluindo-se assim que a regra no se verifica.
Lgica Difusa
No mundo real, longe da computao, existe muito conhecimento que no determinstico,

sendo impreciso, incerto e ambguo. A lgica difusa ou fuzzy remete para uma rea onde se
tenta computar e processar esses dados no determinsticos.
O raciocnio humano frequentemente envolve informao imprecisa (fuzzy), que geralmente
tem origem em conceitos humanos no exatos e associaes a experincias semelhantes em
vez de idnticas. Nos sistemas baseados em lgica clssica onde existem apenas dois valores
2/2
Parceiros:
possveis numa lgica binria (i.e. verdadeiro/falso, sim/no, 0/1) difcil responder a
algumas questes, visto no terem respostas completamente verdadeiras ou completamente
falsas. Os humanos, porm conseguem normalmente dar respostas satisfatrias a este tipo
questes.
A falta de clareza (fuzziness) ocorre quando o limite de uma informao no se encontra bem
definido. Por exemplo, palavras como jovem, idoso; alto, baixo; bom, mau; quente e frio
representam conceitos difusos. No existe um valor quantitativo que defina o termo jovem.
Para algumas pessoas, algum como a idade de 25 anos considerado jovem, para outros 35
considerado jovem. O conceito jovem no tem um limite bem definido. Na maior parte dos
casos pode-se dizer que a idade limite de 1 ano definitivamente considerada jovem e a idade
limite de 100 anos definitivamente considerada no jovem. Porm a idade de 35 anos tem
alguma possibilidade de ser considerada jovem, bem como de ser considerada no jovem,
dependo do contexto.
Uma idade tem sempre alguma possibilidade de ser considerada jovem bem como de ser
considera idosa, como possvel de observar na tabela seguinte.
Tabela 1: Distribuio de dois termos difusos
Idade
25
30
35
40
45
50
Termo Difuso
jovem
1.0
0.8
0.6
0.4
0.2
0.0
Termo Difuso
idoso
0.0
0.2
0.4
0.6
0.8
1.0
Contrariamente lgica clssica, que trabalha com objetos cujo grau de associao a um
conjunto pode ser claramente descrito como pertencente ou no pertencente, em lgica difusa
um elemento pode pertencer parcialmente a vrios conjuntos, com um certo grau de
associao. O grau de associao ao conjunto normalmente representado por valores de 0 a 1
como observvel na tabela anterior, onde 0 significa que no pertence ao conjunto e 1
significando pertence completamente ao conjunto.
Por exemplo na Figura 1 mostrada a distribuio do grau de associao das diferentes idades
para o termo difuso jovem. Ai observvel que para as idades entre 0 e 25, o grau de
2/2
Parceiros:
associao 1 (definitivamente jovem) e entre as idades de 25 a 50 o grau de associao

decresce (idades com alguma possibilidade de serem consideradas jovens).
Figura 1: Distribuio de um termo difuso
A distribuio de um grau de associao de um conceito difuso como de certa forma jovem

ou muito jovem podem ser obtida aplicando operaes aritmticas especificas a distribuio
de jovem, denominando-se de modificadores. Por exemplo, a distribuio do grau de
associao do conceito difuso de certa forma jovem pode ser calculado pela raiz quadrada
dos valores da distribuio de jovem representado na Figura 2.
2/2
Parceiros:
Figura 2: Termo difuso com aplicao de modificador
Em que a curva de probabilidade passa a decrescer menos no inicio, mas depois cai mais
abruptamente.
2/2
Parceiros:
Sistemas de motores de Regras Crisp

Neste captulo sero analisados alguns sistemas j existentes de motores de regras e que
podem ser aplicados em diversos domnios, pois trabalham com regras e no com domnios
concretos.
Jess
O Jess pode ser visto como um motor de regras. No entanto, tambm pode ser visto como uma
linguagem de programao, devido s regras e restries por ele utilizadas terem uma sintaxe
prpria, da o nome tambm remeter para essa linguagem.
O Jess totalmente desenvolvido em JAVA para assegurar questes de compatibilidade multi
sistema. Foi desenvolvido por Ernest Friedman-Hill dos Sandia National Labs e a primeira verso
foi desenvolvida em 1995.
O Jess um super conjunto da linguagem j existente CLIPS, uma linguagem especifica para
motores de regras e expert systems que foi desenvolvido em 1985. O Jess sendo um super
conjunto dessa linguagem, quer dizer que a estende e que a melhora com mais comandos e
ferramentas.
Embora o CLIPS seja completamente Open Source, tal no o caso do Jess. Este gratuito para
fins educacionais e acadmicos, mas necessita de uma licena para ser utilizado em contexto
comercial.
Este motor de regras suporta os mtodos de inferncia backward chaining e forward chaining.
Permite trabalhar com lgica clssica bem como com lgica difusa. O Jess pode ser utilizado de
modo autnomo (standalone) como aplicao especfica, na forma de uma consola/shell ou
at integrado com qualquer aplicao de Java. No modo autnomo tambm possvel
trabalhar com objetos Java.
2/2
Parceiros:
Experimentao Prtica
O software utilizado nesta experimentao, assim como os ficheiros de configurao, cdigo e

regras, encontra-se nas pastas de recursos do QREN Smart Mail.
Nos testes efetuados com esta plataforma utilizou-se a verso standalone por via de consola do
prprio Jess. Desta forma evita-se criar um programa Java funcional que integre as
funcionalidades da API do Jess. Utilizando a consola ficamos focados na vertente principal e
mais relevante - estudar e experimentar o Jess.
A verso utilizada para testes a 7.1p2. A consola do Jess tem simplesmente o seguinte apeto:
Figura 3: Consola do Jess pronta a receber comandos
Na consola podem ser inseridos comandos para carregar e executar as rotinas e os programas.
Neste caso tambm possvel observar uma mensagem a dizer que a aplicao vai expirar (tal
deve-se ao facto de ser uma aplicao comercial e de se estar a utilizar para efeitos de teste e
demonstrao).
Os principais comandos da consola so:
(batch ficheiro.clp)
(exit)
(facts
(rules
(run)
(reset)
2/2
Carrega e executa o programa no ficheiro.clp

Sai e fecha a consola
Apresenta os factos carregados em memria
Apresenta as regras carregadas em memria
Corre o programa atual
Faz reset a memria
Parceiros:
Nota: os comandos so sempre envolvidos em parenteses: (comando)
Os ficheiros com as rotinas para o Jess tem a extenso .clp e devem conter trs componentes
principais:
fact-list e instance list: essencialmente so os dados e factos que so dados como certos
no contexto da aplicao
knowledge-base: so todas as regras que vo utilizadas pelo motor de regras
inference engine: o motor de regras propriamente dito
A nvel de variveis essas podem ser declaradas tanto num ficheiro (.clp) ou diretamente na
consola, existindo dois tipos, as variveis locais e globais. De seguida so apresentados alguns
exemplos de declarao para a criao de variveis locais com recurso ao comando (bind):
Figura 4: Declarao de Variveis Locais
Neste exemplo declarada uma varivel numrica simples, uma lista de valores, e uma classe
de Java.
A declarao de variveis globais semelhante, mas com recurso ao comando (defglobal)
Figura 5: Declarao de varivel Global
A definio de funes pode ser vista no exemplo seguinte:
Neste caso a funo myMath recebe trs argumentos e efetua a diviso entre os primeiros dois
e soma o resultado ao terceiro argumento. H a salientar que utilizada a notao Polanesa em
2/2
Parceiros:
que os operadores surgem primeiro que os valores. De seguida apresentado um exemplo de

chamada a essa funo com o retorno do resultado.
Os factos no Jess so vistos como dados que so considerados como certos e que podem ser
utilizados na resoluo de regras. Existem dois tipos principais de factos, os ordenados e os
desordenados. Os factos ordenados so simples listas de conceitos, como por exemplo:
Neste caso foram criados factos, com o comando (assert), para a condio estado do tempo e o
facto para o estado do tempo, para o dia de hoje.
Os factos que j esto definidos podem ser consultados a qualquer altura com recurso ao
comando (facts):
Os factos desordenados so estruturas semelhantes s estruturas do C (i.e. structs), que podem

ser vistos como verses mais bsicas e simplificadas de Objetos. No exemplo seguinte
apresentada a declarao de uma disciplina:
Para criar uma instncia desse facto basta:
Consultando agora todos os factos do programa com o comando (facts), obtemos:
2/2
Parceiros:
Para definir uma regra que utilize outras regras, os factos ou variveis utiliza-se o comando
(defrule). De seguida apresentado um exemplo simples da criao de uma regra:
Nesta est definida uma regra que inicia o processo de ir almoar caso se tenha fome. Embora
o Jess aceite a definio desta regra, o conceito fome e ir_almoar teriam tambm de ser
definidos como regras, factos ou variveis.
Da mesma forma que existe o comando (facts) para apresentar os factos inseridos no sistema,
aqui tambm pode ser utilizado o comando (rules) para listar as regras j definidas, como por
exemplo:
2/2
Parceiros:
JBoss/Drools
Quando se fala do motor de regras JBoss equivalente a falar do Drools, pois essa componente
do JBoss no mais do que uma verso do Drools transformada em produto empresarial. O
Drools encontra-se assim integrado tanto no produto JBoss Enterprise BRMS e no JBoss Rules
em vertentes comerciais. No entanto tambm se encontra na verso Community do JBoss. O
motor do Drools totalmente open source e gratuito, ao contrrio do Jess que tem sempre
uma licena paga associada.
O JBoss/Drools um dos mais diretos concorrentes do Jess, sobretudo porque tem tido um
grande suporte da comunidade e evoludo bastante a nvel de interfaces grficas. O facto de ser
open source tambm tem ajudado nesse processo evolutivo. Em muitos aspetos semelhante
ao Jess, pois o seu motor baseia-se no RETE, o mesmo do Jess e tambm suporta o standart API
JSR 94 semelhana do Jess. Tambm suporta tanto uma abordagem em Forward Chaining ou
em Backward Chaining na resoluo dos problemas de regras.
Daqui em diante iremo-nos referir a esta aplicao simplesmente por Drools, pois a nossa
anlise ser focada nele e no no JBoss devido a este ser de cariz comercial e haver uma maior
dificuldade no acesso s ferramentas para experimentao.
No Drools existe um conjunto de sub-ferramentas para funcionalidades distintas. Essas

ferramentas so:
Drools Workbench
Drools Expert
Drools Fusion
jBPM
OptaPlaner
O Drools Workbench uma interface grfica que permite gerir e controlar as restantes
ferramentas de uma forma integrada, enquanto o Drools Expert o motor de regras
propriamente dito. Estas duas ferramentas so as que tm mais interesse para este estudo. As
2/2
Parceiros:
restantes aplicaes, embora menos importantes, so o Drools Fusion para a criao e gesto
de eventos computacionais e processos. O jBPM destinado a processos e workflows
integrados com regras. Por fim o OptaPlanner destinado a criao automtica de planos e
workflows.
Experimentao prtica

regras, encontra-se nas pastas de recursos do QREN Smart Mail. Tendo em conta que criar
cenrios complexos de regras um processo moroso, em muitos casos a experimentao foi
baseada em dados exemplos j inseridos na plataforma.
Recorrendo ao Workbench, a grande vantagem desta ferramenta a possibilidade de definir

regras e cenrios complexos com diversas regras de uma forma grfica e mais intuitiva para o
utilizador com menos conhecimentos tcnicos de informtica.
Figura 6: Criao visual de regras
Na Figura 6, apresentado um exemplo de um ecr onde possvel criar e editar regras para o
sistema. Do lado direito possvel identificar trs reas, extends caso esta regra seja uma
sub-regras ou caso especial de outra regra j existente, a parte do when onde so definidos
os parmetros que fazem despoletar a regra e por fim o then com as aes da regra. J do
lado direito possvel visualizar um conjunto de controlos que permitem alterar a ordem dos
parmetros, assim como, adicionar novas clusulas ou restries. Ainda na Figura 7,
apresentado outro exemplo mais complexo.
2/2
Parceiros:
Figura 7: Exemplo mais complexo de uma regra criada visualmente
Tanto o JBoss como Drools tm outra funcionalidade visual para a modelao de um cenrio
complexo de regras. Essa ferramenta designada de tabela de deciso.
Imagine-se o cenrio em que se quer transformar em regras a Tabela 2. Essa tabela tem as
condies de atribuio de dias de frias aos trabalhadores de uma empresa de acordo com a
sua idade e com o seu horrio laboral. O que representado na tabela algo relativamente
simples e intuitivo de ser compreendido, mas que seria bastante moroso e complicado de ser
implementado por via convencional de regras baseadas em if-then. Na tabela essencialmente
cada combinao/clula teria de ser representada implicando uma sequncia enorme de ifthen.
2/2
Parceiros:
Tabela 2: Exemplo de tabela de regras
Na interface grfica possvel criar um motor de regras baseado numa tabela de deciso, o que
simplifica muito estes cenrios, em que a prpria tabela pode ser representada diretamente na
aplicao, que o sistema cria e estrutura automaticamente as regras para representar todas as
hipteses condicionais.
Figura 8: Tabela de Deciso
Na Figura 8 apresentado um exemplo simples em que as colunas so as diversas variveis, e

em cada linha esto parametrizadas essas variveis de modo a cada uma representar uma
condio. Neste exemplo apenas esto definidos diferentes intervalos para os valores da idade.
Ao mesmo tempo que o utilizador define estas regras na tabela, a aplicao trata do seu
mapeamento automtico para o cdigo equivalente, como visvel na Figura 9.
2/2
Parceiros:
Figura 9: Regras geradas automaticamente da tabela de deciso
O topo da tabela de deciso pode ser estendido e permitir a insero de clausulas mais
complexas em cada coluna, permitindo tambm uma leitura mais rpida, como visvel na Figura
10
Figura 10: Exemplo de tabela expandida
2/2
Parceiros:
As regras podem ainda ser redefinidas de uma forma extremamente gil com recurso vista de
matriz. No exemplo da Figura 11, continuamos a ter as variveis e regras parciais no topo, no
entanto so apresentadas 8 regras finais distintas, com diferentes combinaes das colunas.
Essas combinaes so facilmente alterveis. Caso essas alteraes fossem efetuadas ao nvel
do cdigo, iria ser um processo bastante moroso e com propenso a erros devido grande
complexidade e quantidade de if-then envolvidos.
Figura 11: Alterao das regras por matriz
2/2
Parceiros:
Drools.NET
Como j foi introduzido, o JBoss e o Drools so essencialmente a mesma aplicao, com
pequenas diferenas mas partilhando as mesmas bases e os mesmos motores. No entanto, de
salientar que existe o designado de Drools.NET, que essencialmente um wrapper da verso
open source do Drools. Este wrapper migra as suas funcionalidades para tecnologia .NET e tem
as mesmas funcionalidades base e hierarquia de API. Dessa forma, facilmente se consegue
integrar essas funcionalidades em ambiente .NET.
No ser efetuada uma anlise em profundidade a esta ferramenta por ser uma
reimplementao do Drools j anteriormente analisado.
O software do Drools.NET, assim como os ficheiros de configurao, cdigo e regras, encontrase nas pastas de recursos do QREN Smart Mail.
Prolog
O Prolog uma linguagem de programao declarativa que surgiu pela primeira vez em 1972.
No entanto, tal idade no significa que est ultrapassada ou desatualizada, pelo contrrio
bastante utilizada em reas como o processamento de lngua natural e em muitos campos da
inteligncia artificial.
O Prolog orientado a factos, regras e restries, o que o torna um motor de regras puro por
excelncia. O Prolog s resolve os seus problemas de regras com recurso abordagem
Backward Chaining, mas isso no restrio nenhuma, pois os problemas que so resolvido por
Forward Chaining tambm o so por Backward Chaining. A nica desvantagem que pode da
advir, que se torna um pouco mais confuso, perceo da resoluo dos problemas, para
utilizadores menos experientes com a lgica inversa do Backward Chaining.
Experimentao Prtica
2/2
Parceiros:

Na experimentao prtica utilizou-se o SWI-Prolog simplesmente por ser uma das variantes
com interface mais limpa e com mais documentao e comunidade, o que facilitou todo o
processo. No entanto, todos os testes efetuados podiam ser realizados em qualquer plataforma
de Prolog. Para mais detalhes consultar as Variantes de Prolog na seco seguinte deste
documento.
Para ser possvel trabalhar com o Prolog necessrio criar um programa com um conjunto de
regras e factos como ponto de partida.
O programa criado, a titulo de exemplo, tem um conjunto de regras que indicam as
preferncias gastronmicas do Nuno e da Vera.
Num primeiro bloco adicionaram-se regras com factos sobre os tipos de comidas que o Nuno e
a Vera gostam:
No entanto essas regras apontam para outras regras (tipos de comida), como por exemplo a
comida indiana. S as primeiras duas e as ltimas duas regras que apontam para factos
terminais. Assim sendo necessrio definir essas regras de segunda ordem:
Desta forma os tipos de comida ficam definidos com factos terminais. No sendo necessrio
definir mais sub regras, pois todos os dados, direta ou indiretamente, convergem para factos.
2/2
Parceiros:
Tendo o ficheiro criado com as regras de Prolog (encontra-se nas pastas de recursos do QREN
Smart Mail com o nome de gostos.pl) ento possvel iniciar o SWI-Prolog (visvel na Figura
12) sobre esta base de conhecimento.
Figura 12: Aspeto da consola do SWI-Prolog
Aqui, podem ser realizadas querys bsicas sobre as preferncias do Nuno, chamando a regra
likes e passando como atributos a pessoa e a comida, o sistema responde true ou false
consoante a sua base de conhecimento e de factos:
O mesmo possvel realizar sobre os tipos de comida indiana, mas havendo s um argumento
nesta regra:
2/2
Parceiros:
Tambm possvel listar os tipos de comida indiana, nesse caso, em vez de se passar um
argumento vlido, passa-se uma incgnita X, e o sistema devolve todas as condies que
satisfaam o facto de ser comida indiana:
O mesmo pode ser realizado sobre a regra likes, em que se passa uma incgnita no segundo
argumento, de seguida so apresentados os resultados para o caso vera e nuno:
No caso da Vera apenas existia um facto direto que foi prontamente apresentado, j no caso do
Nuno, as respostas apresentadas no se referem a outras regras como comida indiana, chinesa,
etc, mas sim aos factos elementares que so obtidos por essas regras (comida indiana, chinesa,
etc).
Ainda possvel para a funo likes passar duas incgnitas nos argumentos, nessa situao o
sistema ir dar todas as combinaes possveis de acordo com os factos que foram definidos no
ficheiro com os factos e as regras:
2/2
Parceiros:
Onde se pode observar que aparecem extensivamente todos os gostos do Nuno e da Vera, que
neste caso apenas um.
Variantes
Existem diversas variantes de aplicaes e plataformas onde possvel trabalhar com Prolog.
As principais e mais difundidas so o GNU Prolog e o SWI-Prolog.
O GNU Prolog uma das ferramentas mais antigas nesta rea e essencialmente uma consola
que permite executar ficheiros de Prolog e depois efetuar consultas sobre essas regras e
clausulas. O GNU Prolog tambm oferece uma ferramenta de debugging interativa que permite
detetar erros, mas tambm permite executar a passo-e-passo o fluxo de resoluo de uma
query.
J o SWI-Prolog muito semelhante ao GNU Prolog, com destaque para o debugger que aqui
uma ferramenta grfica e mais apelativa para os utilizadores menos experientes.
Ambas as ferramentas so desenvolvidas em C e comportam-se como interpretadores que
processam o cdigo Prolog e o compilam nativamente, dependendo do sistema onde so
executados. Ambas as ferramentas so open source e gratuitas.
2/2
Parceiros:
Ainda se destaca a ferramenta JLog que uma reimplementao de um interpretador de Prolog

mas feita em Java. Com esta ferramenta, possvel executar programas com regras de Prolog
num ambiente JAVA.
O passagem do Prolog para outras plataformas no se fica pelo JAVA, tambm possvel utilizalo em ambeientes .NET, recorrendo por exemplo ao C# Prolog ou ao Prolog .NET. Estas
bibliotecas/ferramentas tambm so interpretadores de Prolog que permitem a interao por
via de consola, mas que tambm permitem embutir as funcionalidades e capacidades do Prolog
em qualquer programa desenvolvido em ambiente .NET.
2/2
Parceiros:
Sistemas de motores de Regras Fuzzy

Fuzzy Jess
O Fuzzy Jess como o nome indica uma variante do Jess destinada a ser aplicado em contextos
no determinsticos de logica difusa.
Essa variante Jess obtida por via do NRC FuzzyJ Toolkit, mais simplesmente conhecido por
FuzzyJ que foi desenvolvido pelo Institute for Information Technology do National Research
Council of Canada e semelhana do Jess gratuito para utilizao acadmica, mas com licena
paga para utilizao comercial, isso at verso 1.2. Na verso 2.0 o software passou a ser de
domnio publico e open source sobre a licena Mozila Public Licence V2.0.
O FuzzyJ Toolkit no mais do que um conjunto de classes e mtodos disponveis em
lingauagem JAVA que permitem adicionar ao Jess a capacidade de lidar com conceitos difusos,
variveis, termos, factos e regras. Apenas quando se adicionam as classes do FuzzyJ Toolkit ao
Jess, que se passa a designar de Fuzzy Jess.
O desenvolvimento do FuzzyJ/Fuzzy Jess foi baseado na extenso FuzzyCLIPS desenvolvida para
o sistema CLIPS.
Experimentao Prtica

Na experimentao prtica iniciou-se por explorar os conceitos mais simples, nomeadamente

as variveis semmticas, que agora so definidas por intervalos ao invs de valores discretos.
Como cenrio de testes foi utilizado um hipottico sistema com o objetivo de regular
automaticamente a temperatura e o fluxo de gua baseado em regras difusas. As linhas de
cdigo que vo ser apresentadas e analisadas de seguida, so inseridas em ficheiros clp, o
2/2
Parceiros:
mesmo tipo de ficheiros de instrues utilizado pelo Jess normal (i.e. crisp e ser recurso a
modelao fuzzy).
Inicialmente define-se a varivel temperatura, onde se atribui o nome e o intervalo (0 - 100) e

ainda a unidade. Destaque para o tipo declarado FuzzyVariable.
De seguida, essa varivel necessita de ser parametrizada de modo a tornar-se difusa. Com esse
propsito so definidos arrays de intervalos, onde so definidas as condies quente e fria:
Para a intervalo Hot e Cold existem duas variveis, nomeadamente X e Y. A componente X

representa os valores que se vo sobrepor escala de temperatura (0-100), enquanto a
varivel Y representa a sua intensidade normalizada, ou seja, Hot a 27 graus ser
subjetivamente pouco quente, enquanto Hot a 35 graus ser bastante quente, sendo linear
essa variao entre o intervalo de 25 a 35 graus.
Para a definio de Cold ocorre o mesmo, mas de forma inversa, ou seja, 5 ser muito frio,
enquanto 15 ser pouco frio.
Estes intervalos ainda tm de ser associados varivel de temperatura temp anteriormente
definida:
Tanto o intervalo difuso Hot e Cold foram definidos explicitamente, no entanto, o Fuzzy
Jess permite definir outros intervalos implicitamente custa de outros. De seguida
apresentado um exemplo onde efetuada a criao do intervalo Medium para a temperatura
compreendida entre o Hot e o Cold, sendo efetuado com recurso a uma expresso
lingustica:
Para se ter uma melhor perceo visual sobre os conjuntos j definidos sobre a temperatura
apresentado um grfico que os ilustra:
2/2
Parceiros:
Figura 13: Grfico com os intervalos definidos
Com estes intervalos definidos j possvel efetuar algumas consultas simples, como por
exemplo, qual o intervalo que satisfaz a condio frio e muito quente, para tal basta inserir na
consola essa pesquisa sendo devolvido o intervalo que lhe obedece:
O resultado obtido parece confuso, mas no passa de uma listagem de pares ordenados na
forma (Y,X), onde o primeiro valor representa a intensidade e o segundo a sua posio ao longo
do eixo XX, que neste caso, corresponde temperatura. Esse mesmo conjunto de pares
ordenados mapeado para um grfico obtm aproximadamente:
Figura 14: Grfico resultante da query
2/2
Parceiros:
No entanto, os intervalos que foram definidos foram sempre de transio retilnea e linear, o
que pode no ser suficiente para modular casos mais complexos de lgica difusa. Para
contornar essa limitao o Fuzzy Jess tem um conjunto de classes que podem ser utilizadas
para modelar exemplos mais complexos. Baseando-se tanto em formas primitivas como na
unio e interceo entre elas.
Uma dessas classes mais simples passa pela definio de tringulos, onde se utiliza a classe
triangleFuzzySet, como se pode observar no exemplo seguinte:
Em que cada valor indica a posio (XX) de cada vrtice. Com esta especificao seria possvel
definir uma varivel difusa com o seguinte formato:
Figura 15: Intervalo em forma de triangulo
ainda possvel definir formas completamente irregulares, para isso basta definir dois arrays
paralelos, um para os valores de Y e outro para valores de X, e por fim declarar um FuzzySet
construdo com esses dois arrays, como apresentado no exemplo seguinte:
A visualizao grfica desta varivel difusa irregular seria algo aproximadamente da seguinte
forma:
2/2
Parceiros:
Figura 16: Intervalo difuso irregular
Sobre diferentes variveis fuzzy irregulares, ainda possvel, aplicar operaes de unio e de
interseo recorrendo ao cdigo seguinte:
O efeito dessas operaes pode ser observado nas imagens seguintes, respetivamente:
Figura 17: Interseo de Intervalos
Figura 18: Unio de Intervalos
2/2
Parceiros:
FuzzyCLIPS
O FuzzyCLIPS uma extenso do sistema de regras CLIPS que permite trabalhar com regras de
lgica difusa. O sistema CLIPS por sua vez foi o que serviu de base para o desenvolvimento do
Jess e do Fuzzy Jess j anteriormente analisados neste documento.
Tanto o CLIPS como o FuzzyCLIPS so completamente open source e gratuitos para uso
educacional ou cientfico.
A sigla do CLIPS significa C Language Integrated Production System e foi desenvolvido
inicialmente para a NASA em 1985 com o objetivo de ser uma linguagem para o
desenvolvimento de expert systems. O nome original deste projeto era NAIL sigla de
NASA's AI Language.
Embora a linguagem utilizada no CLIPS tenha uma sintaxe prpria e relativamente de alto nvel,
o funcionamento interno do motor do CLIPS todo desenvolvido em C. Ainda assim, o
utilizador comum do CLIPS no necessita de saber programar em C.
O CLIPS pode executar de forma autnoma atravs de uma simples consola consumindo
ficheiros .clp com instrues CLIPS, ou ento, pode ser utilizado embutidos noutros programas
desenvolvidos em C.
Experimentao Prtica
Para os testes efetuados foi utilizada a verso 6.10 do FuzzyCLIPS. O software utilizado nesta
experimentao, assim como os ficheiros de configurao, cdigo e regras, encontra-se nas
pastas de recursos do QREN Smart Mail.
A experimentao prtica iniciou-se por explorar os conceitos mais simples, nomeadamente as

variveis que so definidas por intervalos ao invs de valores discretos. As linhas de instrues
que vo ser apresentadas e analisadas de seguida so inseridas em ficheiros clp, o mesmo tipo
de ficheiros de instrues utilizado pelo CLIPS convencional.
2/2
Parceiros:
Recorrendo a um exemplo j utilizado anteriormente, pretende-se definir a varivel difusa de

idade. Para tal necessrio definir um intervalo que o conceito novo e velho absoluto, e reas
de transio. Para tal, utiliza-se o seguinte cdigo CLIPS:
Onde declarada a varivel age e os conceitos que atuam sobre ela, nomeadamente young
e old. Na definio do conceito young so indicados dois extremos de intervalos em que o
primeiro valor representa o eixo XX e o segundo o eixo do YY. Para o primeiro intervalo, o
primeiro valor a posio (idade) at onde absolutamente novo (25) e o segundo valor a
probabilidade de ser novo. J o segundo intervalo indica a posio (idade) a partir do qual
jamais ser considerado novo (50) com probabilidade zero. Desta forma, est explicitamente
indicado dois intervalos, at onde novo com probabilidade 1, e a partir de onde, a
probabilidade de ser novo zero. Implicitamente tambm est definida a zona de transio (de
25 a 50), em que a probabilidade de ser novo vai decrecer linearmente.
O mesmo acontece para a definio do termo old, onde so definidos explicitamente os
intervalos de probabilidade 1 e zero e implicitamente definido o intervalo de transio.
A ttulo de exemplo fica o grfico linear da componente young:
Figura 19: Grfico do intervalo difuso para young
2/2
Parceiros:
No Fuzzy CLIPS tambm possvel definir regras com grau de incerteza, o que pode ser
bastante til nos contextos de logica difusa. Essas regras, ao contrrio das variveis, podem ser
aplicadas em diferentes contextos e acabam por ter uma maior expressividade. De seguida
apresentado um exemplo para uma regra que define a probabilidade/grau de incerteza de uma
ave voar:
Como possvel observar, a linguagem CLIPS muito verbosa, assemelhando-se bastante

lngua natural. No exemplo indicado que o fator da regra (Conditional Factor) de 0,95. Assim
a regra indica que se o animal for do tipo ave, h uma probabilidade de 95% de este voar. A
mesma regra num cenrio de logica binria convencional, baseado em if/then, iria ter uma
clusula simples em que se o animal fosse uma ave, iria voar. Desta forma consegue-se
observar que as regras difusas so mais adaptativas ao mundo real.
As regras no Fuzzy CLIPS podem ter trs tipos diferentes de acordo com o seu grau de
fuzzyness, esses tipos so o CRISP Rule, FUZZY-CRISP Rule e FUZZY-FUZZY Rule.
No primeiro caso de CRISP Rule, apresentado o seguinte exemplo constitudo por uma regra e
seguido de um facto que evocado nessa mesma regra:
2/2
Parceiros:
A regra define (assert) a condio de fraca iluminao/escuro, tendo duas premissas, uma de
incerteza para esse facto de estar escuro (declare (CF 0.7)) e outra premissa, que o
interruptor da luz estar desligado. No entanto, essa premissa um facto que definido fora da
regra, tendo tambm um grau de incerteza na sua definio (light_switch off CF 0.8).
Nestas sisuaes o Fuzzy CLIPS resolve estas condies (regras de incerteza com factos de
incerteza) de uma forma algbrica muito simples, que poderia ser representada da seguinte
forma:
CF=CFr * CFf
Onde CFr o fator condicional da regra e CFf o fator condicional do facto. Assim inquirindo o
sistema sobre a condio illumination level dark o sistema responde que o fator condicional
(global) dessa regra :
Que simplesmente o valor condicional global da regra e que obtido pela multiplicao dos
dois fatores condicionais que a compem.
No tipo de regras FUZZY-CRISP, a regra vai ter uma componente de incerteza que a parte
CRISP e vai ter um facto. Ao contrrio do exemplo anterior que tambm era CRISP, aqui vai ser
um facto FUZZY, obtendo-se assim uma regra hibrida com uma condicionante que um facto
de incerteza determinstico, e com outro facto assente em lgica difusa. De seguida
apresentado um exemplo que representa estas regras e condies hibridas:
Como observvel continua a haver a componente CRISPY de incerteza da regra (declare(CF

0.7), no entanto o outro facto em que a regra assenta (fuzzy-fact fact2) j definido em lgica
difusa.
2/2
Parceiros:
Por fim o terceiro tipo de regras do FuzzyCLIPS o tipo designado de FUZZY-FUZZY e como o
nome indica, aqui toda a regra assente e pressupostos difusos. Tanto os pressupostos como a
concluso/resposta da regra, que tambm tem um output difuso. Sendo apresentado de
seguida um exemplo:
Esta regra assenta apenas num facto difuso (temperature hot), e como resultado, tambm
apresenta uma ao difusa (temp_change little)). Tanto o hot como o little so factos
difusos com um intervalo probabilstico associado.
Os intervalos difusos normalmente definidos no Fuzzy CLIPS so transies lineares, como j

tinham sido apresentado:
Figura 20: Intervalo linear
No entanto possvel definir outras formas para os limites destes intervalos difusos.
Recorrendo s funes Z, PI e S e tornar assim os intervalos difusos menos lineares na regio de
transio. Para melhor compreender o que cada funo faz, apresentado de seguida um
exemplo grfico de cada:
2/2
Parceiros:
Figura 21: Grficos das funes S, Z e PI
A nvel de cdigo CLIPS, para aplicar estes comportamentos aos intervalos bastante simples,
como visvel observar no exemplo seguinte, onde so definidos trs intervalos, cada um com
a sua funo:
possvel observar que os intervalos receberam parmetros extras, no caso do cold recebeu
o z, no OK recebeu o PI e por fim no hot recebeu o parmetro s. Dessa forma os trs
intervalos tero transies como as assinaladas nos grficos anteriores em vez de serem
simplesmente lineares.
Outra funcionalidade interessante que o Fuzzy CLIPS apresenta para a manipulao de

intervalos difusos a capacidade de aplicar modificadores. Os modificadores de um intervalo
aplicam sobretudo alteraes do valor Y do intervalo. Sendo esta outra forma de fazer com que
os intervalos difusos no seja simplesmente lineares e que possam tomar outras formas. De
seguida apresentada uma tabela resumo desses modificadores:
Tabela 3: Modificadores do FuzzyCLIPS
Nome do Modificador
not
very
somewhat
more-or-less
2/2
Alterao
1-Y
Y^2
Y^0,333
Y^0,5
Parceiros:
extremely
intensify
Y^3
Y^2 if Y in [0 0,5]
1-2(1-Y)^2 if Y in [0,5 - 1]
norm
slightly
De seguida ser apresentada uma representao grfica de cada modificador para uma melhor
perceo dos mesmos.
Figura 22: Intervalo onde sero aplicados os modificadores
Figura 23: Modificador Not
2/2
Figura 24: Modificador Very
Parceiros:
Figura 25: Modificador More-or-Less

Figura 26: Modificador Somewhat
Figura 27: Modificador Slightly
Figura 29: Modificador de Normalizao
Figura 28: Modificador Intensity
Figura 30: Modificador Extremely
Para chamar estes modificadores basta evocar o seu nome na declarao do intervalo. No
cdigo seguinte apresentado um exemplo de como aplicar uma dessas transformaes.
2/2
Parceiros:
Neste exemplo o intervalo cold e hot so definidos de forma convencional, no entanto, o

intervalo freezing definido com a transformao do intervalo cold, neste caso o
transformador utilizado foi o extremely.
2/2
Parceiros:
fuzzyTECH
O fuzzyTECH uma ferramenta inicialmente desenvolvida em ambiente acadmico, mas que
posteriormente passou a ser comercializado pela empresa alem INFORM. Embora seja uma
ferramenta proprietria esto disponveis verses de demonstrao com a limitao de no se
poder guardar as alteraes efetuadas nos projetos. No entanto, mesmo com esta limitao,
possvel analisar e estudar as funcionalidades e a abordagem.
O software em si um motor de regras difusas, no entanto, ao contrrio das ferramentas j
analisadas que se resumiam a ser simples bibliotecas, esta aplicao tem uma forte
componente de simulao grfica e de controlo em sistemas reais, com a mais-valia de recorrer
a lgica difusa. A necessidade de desenvolver este sistema deveu-se ao facto de muitos
sistemas de controlo baseados em lgica clssica no serem suficientemente adaptativos e
elsticos s realidades que se pretendia modular e controlar. Em que a deciso baseada em
regras booleanas no era suficiente. Por exemplo controlar uma vlvula de presso ou a
velocidade de um motor no pode ser binrio, tudo ou nada, tem de haver um comportamento
progressivo e adaptativo.
Esta ferramenta utilizada nas mais diversas reas que envolvam automao e controlo de
sistemas. Muitas vezes a aplicao est conectada a sistemas de controlo que permitam efetuar
aes, como por exemplo ligar e desligar interruptores, regulao de vlvulas e acesso a
sensores. As reas onde utilizado vo desde o controlo de gruas, incineradores, de caldeiras,
de controlo climtico de edifcios, controlo de geradores elicos e solares, controlo de guas
pluviais e de guas residuais, prensas, etc.
Experimentao prtica
Esta ferramenta para alm de ter uma linguagem prpria para definir termos, regras e
conceitos difusos, semelhana das aplicaes analisadas anteriormente, possui ainda uma
componente grfica bastante forte, onde possvel analisar graficamente a flutuao das
diversas variveis difusas e obter assim uma visualizao diferente de um ecossistema difuso.
Essas variveis podem, inclusivamente, ser analisadas em tempo real numa sequncia de fluxo
temporal.
2/2
Parceiros:
Numa primeira anlise foi construdo um modelo muito simplista a ttulo de exemplo.
Posteriormente, numa segunda fase foram analisados modelos exemplo j existentes muito
mais complexos e detalhados.
Ao abrir a ferramenta (Figura 31) apenas apresentado o editor vazio. No entanto do lado
esquerdo j possvel visualizar uma rvore de estruturao do projeto, com especial destaque
para os Inputs e Outputs do sistema dentro do grupo de variveis. Essas variveis so difusas,
tanto as de entrada como as de sada.
Figura 31: Projeto vazio
Embora a criao de regras e variveis difusas possa ser definida diretamente num ficheiro de
cdigo, como nas aplicaes j analisadas, neste ambiente possvel ainda efectuar grande
parte dessa definio e modelao por via da interface grfica.
A maneira mais fcil de se comear iniciando o Wizard (Figura 32) e seguir um conjunto de
passos mais ou menos intuitivos.
O primeiro passo (Figura 33, esquerda) onde se define se o projecto tem inicio com base
num conjunto de regras j existentes num outro projecto, ou se criado de raiz.
No passo seguinte (Figura 33, direita) definido o nmero de variveis de entrada, neste caso
duas, o nmero de variveis intermdias, neste caso nenhuma e tambm onde se define o
nmero de entradas e de sada, neste caso uma. Para cada tipo de varivel (entrada, intermdia
e sada) possvel definir o nmero de intervalos (termos) para esse tipo de variveis. Cada
intervalo da varivel ter de estar associado a um termo lingustico (ex: Low, muito, pouco, ).
2/2
Parceiros:
Figura 32: Wizard de projeto simples
Figura 33: Tipo de projeto e nmero de variveis
Na Figura 34 ( esquerda) onde podem ser atribudos nomes s variveis, o intervalo de

amplitude e novamente o nmero de termos, assim, como a designao para esses termos. J
na Figura 34 ( direita), onde se define o tipo de output para conectar a dispositivos fsicos de
controlo tal no sendo relevante para a nossa experimentao.
2/2
Parceiros:
Figura 34: Definio das variveis e do formato de sada
Figura 35: Definio dos blocos de regras
Por fim na Figura 35 onde se define o nmero de blocos de regras (i.e. neste caso simples vaise criar apenas um bloco).
Concluindo o wizard, ento apresentado o diagrama da Figura 36, que representa as duas
variveis de entrada (in1, in2), o bloco de regras e a varivel de sada (out1).
2/2
Parceiros:
Figura 36: Diagrama obtido
No diagrama, efetuando um duplo clique numa das variveis de entrada surge o que
representado na Figura 37, onde low, medium e high so os termos difusos anteriormente
definidos para a varivel 1.
Figura 37: Mapeamento da varivel difusa 1
Do lado esquerdo podem ser selecionados os diferentes termos, enquanto que no lado direito,
na representao grfica surge um conjunto de pontos que permite que esses termos sejam
alterados e reajustados. Tal visualizado na Figura 38.
2/2
Parceiros:
Figura 38: Alterao de um ponto do termo Medium
Voltando ao diagrama do projeto, se efetuarmos um duplo clique no bloco de regras (RB1)

aparece a tabela de regras associadas ao comportamento das diversas variveis de entrada e ao
consequente comportamento para a varivel de sada.
Figura 39: Tabela de regras
Cada linha representa uma regra e como possvel de observar as regras esto baseadas nos
termos difusos anteriormente referidos. O mapeamento de regras foi definido
2/2
Parceiros:
automaticamente, mas possvel ao utilizador alterar as regras j existentes, remover ou

adicionar novas regras.
Por fim, no diagrama principal do projeto, se for efetuado duplo clique na varivel de sada
(out1) apresentado outro quadro semelhante ao das variveis de entrada como visvel na
Figura 40.
Figura 40: Mapeamento da varivel difusa de saida
Aqui existem mais termos do que nas variveis de entrada, nomeadamente cinco, mas o
funcionamento o mesmo, permitindo ajustes / modelao manual.
Esta ferramenta dispe de funcionalidades avanadas de visualizao da interao entre as
diversas variveis e regras difusas. Para as analisar no vai ser utilizado o exemplo anterior, por
ser muito simples e pouco expressivo. O exemplo que vai ser utilizado aplicado no controlo e
automao de gruas que transportam objetos do ponto X ao ponto Y. Neste cenrio, tambm
existem apenas duas variveis de entrada, a distncia que se encontra do objetivo e o angulo
do cabo que segura o objeto transportado pela grua. Como varivel de sada e de controlo a
intensidade do motor que faz mover a grua. O desafio deste problema tem a ver com o facto de
quanto mais longe estiver mais rpido se quer meter o motor a funcionar, s que essas
aceleraes, tm de ser contidas e controladas de acordo com o angulo do cabo da grua de
modo a evitar perder o controlo.
Figura 41: Diagrama de controlo de grua
2/2
Parceiros:
Figura 42: Termos e intervalos difusos do angulo e distncia da grua
Figura 43:Tabela de regras entre distncia, angulo e fora do motor
Na Figura 42 so apresentados os intervalos difusos e os seus diferentes termos para as

variveis de entrada. Na Figura 43 apresentada a tabela das regras que operam sobre essas
variveis.
Este exemplo apresenta ainda uma simulao que permite observar o funcionamento das
regras em tempo real como apresentado na Figura 44. Nesta imagem e no seu canto inferior
direito tambm possvel observar os valores em tempo real das variveis envolvidas.
Existe tambm um painel de Debug (Figura 45) em que com um slider possvel alterar o valor
das variveis de entrada e ver o valor obtido pela varivel de sada.
2/2
Parceiros:
Figura 44: Simulao das regras fuzzy
Figura 45: Painel de Debug
Existem ainda modos de visualizao avanada entre as variveis difusas de entrada e de sada,
como visvel na Figura 46 e na Figura 47, onde facilmente possvel observar em tempo real a
relao causa efeito entre as diversas variveis envolvidas. Na primeira de uma forma
bidimensional com um grfico para cada varivel. Na segunda visualizao, j de forma
tridimensional e com todas as variveis agregadas.
2/2
Parceiros:
Figura 46: Visualizao bidimensional das variveis de entrada e de sada
Figura 47: Visualizao tridimensional das variveis de entrada e de sada
Exemplos muito mais complexos podem ser modulados como o caso seguinte, que retrata o
controlo de uma caldeira de gerao de vapor. Aqui esto envolvidas diversas variveis de
entrada, de sada e diversos blocos de regras para controlar este sistema complexo. Como
possvel visualizar na Figura 48 e na Figura 49 um caso muito mais complexo, mas ainda
assim, bem modulado com recurso a variveis e regras difusas.
2/2
Parceiros:
Figura 48: Animao em tempo real com todas as variveis difusas
Figura 49: Diagrama de controlo com diversas variveis e blocos de regras
2/2
Parceiros:
jFuzzyLogic
O jFuzzyLogic uma biblioteca open source desenvolvida em Java e destinada a implementar
motores de regras difusos, assim como definir regras e executar aces de deciso sobre as
mesmas.
Tenta-se distinguir de outras bibliotecas semelhantes por anunciar que implementa o standard
de FCL (Fuzzy Control Languange) IEC 61131 Part 7, um standard criado para normalizar
linguagem de controlo baseadas em lgica difusa.
Como apenas uma biblioteca, as suas funcionalidades no funcionam por si s, tem de ser
embutido num programa em JAVA que faa a inicializao e chamada dos seus mtodos e
objectos.
A definio das variveis e termos difusos no feita na sintaxe de JAVA mas sim numa sintaxe
prpria definida pelo standard anteriormente referido.
De seguida da apresentado um exemplo de declarao de uma varivel assim como dos seus
termos:
A sintaxe bastante semelhante s linguagens anteriormente analisadas, em que primeiro

definida a varivel em si, e posteriormente os termos com recurso a pontos bidimensionais
para definir a forma e amplitude de cada termo difuso.
A biblioteca ainda tm algumas funcionalidades bsicas para criar applets para desenhar essas
variveis e respectivos termos. Na Figura 50 so apresentados alguns exemplos dessas
visualizaes. O cdigo analisado anteriormente referente a varivel Service pode tambm
ser visualizado no canto superior direito da mesma figura.
2/2
Parceiros:
Figura 50: Servlets com variveis difusas
2/2

Análise de Motores de Regras

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Análise de Motores de Regras

Transféré par

Droits d'auteur :

Formats disponibles

SmartMail| Entidade Promotora:

SmartMail| Entidade Promotora:

SmartMail| Entidade Promotora:

SmartMail| Entidade Promotora:

Figura 34: Definio das variveis e do formato de sada ............................................................ 50

SmartMail| Entidade Promotora:

SmartMail| Entidade Promotora:

SmartMail| Entidade Promotora:

IF Emissor importante E Assunto importante

SmartMail| Entidade Promotora:

SmartMail| Entidade Promotora:

SmartMail| Entidade Promotora:

Aproximaes dos motores de regras

Nesta abordagem o algoritmo de inferncia forward chaining parte de um conjunto de dados

Onde esto definidas as seguintes regras:

If X coaxa e come moscas Then X um sapo.

SmartMail| Entidade Promotora:

Nesta abordagem o processo um pouco invertido em relao ao Forward Changing. Ao invs

SmartMail| Entidade Promotora:

E com as mesmas regras:

If X coaxa e come moscas Then X um sapo.

No entanto tambm se inicia com a hiptese que se pretende suportar:

SmartMail| Entidade Promotora:

Alguns sistemas baseados em regras, especialmente o Prolog e seus derivados, suportam

No mundo real, longe da computao, existe muito conhecimento que no determinstico,

SmartMail| Entidade Promotora:

SmartMail| Entidade Promotora:

associao 1 (definitivamente jovem) e entre as idades de 25 a 50 o grau de associao

Figura 1: Distribuio de um termo difuso

A distribuio de um grau de associao de um conceito difuso como de certa forma jovem

SmartMail| Entidade Promotora:

Figura 2: Termo difuso com aplicao de modificador

SmartMail| Entidade Promotora:

Sistemas de motores de Regras Crisp

SmartMail| Entidade Promotora:

O software utilizado nesta experimentao, assim como os ficheiros de configurao, cdigo e

Figura 3: Consola do Jess pronta a receber comandos

Os principais comandos da consola so:

Carrega e executa o programa no ficheiro.clp

SmartMail| Entidade Promotora:

Nota: os comandos so sempre envolvidos em parenteses: (comando)

Figura 4: Declarao de Variveis Locais

Figura 5: Declarao de varivel Global

A definio de funes pode ser vista no exemplo seguinte:

SmartMail| Entidade Promotora:

que os operadores surgem primeiro que os valores. De seguida apresentado um exemplo de

Os factos desordenados so estruturas semelhantes s estruturas do C (i.e. structs), que podem

Para criar uma instncia desse facto basta:

Consultando agora todos os factos do programa com o comando (facts), obtemos:

SmartMail| Entidade Promotora:

SmartMail| Entidade Promotora:

No Drools existe um conjunto de sub-ferramentas para funcionalidades distintas. Essas

SmartMail| Entidade Promotora:

O software utilizado nesta experimentao, assim como os ficheiros de configurao, cdigo e

Recorrendo ao Workbench, a grande vantagem desta ferramenta a possibilidade de definir

Figura 6: Criao visual de regras

SmartMail| Entidade Promotora:

Figura 7: Exemplo mais complexo de uma regra criada visualmente

SmartMail| Entidade Promotora:

Tabela 2: Exemplo de tabela de regras

Figura 8: Tabela de Deciso

Na Figura 8 apresentado um exemplo simples em que as colunas so as diversas variveis, e

SmartMail| Entidade Promotora:

Figura 9: Regras geradas automaticamente da tabela de deciso