Professional Documents
Culture Documents
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
Experimentao Prtica ........................................................................................................ 27
Variantes ............................................................................................................................... 31
Sistemas de motores de Regras Fuzzy .......................................................................................... 33
Fuzzy Jess ................................................................................................................................... 33
Experimentao Prtica ........................................................................................................ 33
FuzzyCLIPS ................................................................................................................................. 38
Experimentao Prtica ........................................................................................................ 38
fuzzyTECH .................................................................................................................................. 47
Experimentao prtica ........................................................................................................ 47
jFuzzyLogic ................................................................................................................................. 58
2/2
Projeto em curso com o apoio de:
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
Projeto em curso com o apoio de:
Parceiros:
2/2
Projeto em curso com o apoio de:
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
Projeto em curso com o apoio de:
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
Projeto em curso com o apoio de:
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:
2/2
Projeto em curso com o apoio de:
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
Projeto em curso com o apoio de:
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
Projeto em curso com o apoio de:
Parceiros:
Forward Chaining
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
2/2
Projeto em curso com o apoio de:
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
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
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
Projeto em curso com o apoio de:
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.
Lgica Difusa
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
Projeto em curso com o apoio de:
Parceiros:
2/2
Projeto em curso com o apoio de:
Parceiros:
Em que a curva de probabilidade passa a decrescer menos no inicio, mas depois cai mais
abruptamente.
2/2
Projeto em curso com o apoio de:
Parceiros:
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
Projeto em curso com o apoio de:
Parceiros:
Experimentao Prtica
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:
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).
(batch ficheiro.clp)
(exit)
(facts
(rules
(run)
(reset)
2/2
Projeto em curso com o apoio de:
Parceiros:
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):
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)
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
Projeto em curso com o apoio de:
Parceiros:
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):
2/2
Projeto em curso com o apoio de:
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
Projeto em curso com o apoio de:
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.
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
Projeto em curso com o apoio de:
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
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
Projeto em curso com o apoio de:
Parceiros:
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
Projeto em curso com o apoio de:
Parceiros:
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.
2/2
Projeto em curso com o apoio de:
Parceiros:
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
2/2
Projeto em curso com o apoio de:
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.
2/2
Projeto em curso com o apoio de:
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
Projeto em curso com o apoio de:
Parceiros:
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
Projeto em curso com o apoio de:
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.
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
Projeto em curso com o apoio de:
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
Projeto em curso com o apoio de:
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
Projeto em curso com o apoio de:
Parceiros:
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
Projeto em curso com o apoio de:
Parceiros:
Experimentao Prtica
Parceiros:
mesmo tipo de ficheiros de instrues utilizado pelo Jess normal (i.e. crisp e ser recurso a
modelao fuzzy).
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:
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
Projeto em curso com o apoio de:
Parceiros:
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:
2/2
Projeto em curso com o apoio de:
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:
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
Projeto em curso com o apoio de:
Parceiros:
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:
2/2
Projeto em curso com o apoio de:
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.
2/2
Projeto em curso com o apoio de:
Parceiros:
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.
2/2
Projeto em curso com o apoio de:
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:
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
Projeto em curso com o apoio de:
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:
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.
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
Projeto em curso com o apoio de:
Parceiros:
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.
Nome do Modificador
not
very
somewhat
more-or-less
2/2
Projeto em curso com o apoio de:
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.
2/2
Projeto em curso com o apoio de:
Parceiros:
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
Projeto em curso com o apoio de:
Parceiros:
2/2
Projeto em curso com o apoio de:
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
Projeto em curso com o apoio de:
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.
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
Projeto em curso com o apoio de:
Parceiros:
2/2
Projeto em curso com o apoio de:
Parceiros:
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
Projeto em curso com o apoio de:
Parceiros:
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.
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
Projeto em curso com o apoio de:
Parceiros:
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
Projeto em curso com o apoio de:
Parceiros:
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.
2/2
Projeto em curso com o apoio de:
Parceiros:
2/2
Projeto em curso com o apoio de:
Parceiros:
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
Projeto em curso com o apoio de:
Parceiros:
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
Projeto em curso com o apoio de:
Parceiros:
2/2
Projeto em curso com o apoio de:
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:
2/2
Projeto em curso com o apoio de:
Parceiros:
2/2
Projeto em curso com o apoio de: