sistemas de produção -...
Post on 17-Jan-2020
12 Views
Preview:
TRANSCRIPT
1
Sistemas de ProduçãoReativos e Algoritmo de Rete
Profa. Josiane
Patrick Henry Winston“Artificial Intelligence” – 3ª edição – cap. 7
agosto/2008
Sistemas de Produção Reativos
As regras são da forma: Se condição então ação
A ação pode inserir uma nova asserção na MT, ou apagar uma asserção existente, ou executar algum outro procedimento.
Três fases: Casamento Resolução de conflitos e Execução
BAGGER: Um Sistema Reativo
Objetivo: empacotar gêneros alimentícios em uma mercearia BAGGER: decide onde cada item deve ir (em qual sacola) BAGGER foi projetado para fazer 4 passos:
Checar: analisa o que o cliente selecionou, verifica se algum item está faltando e sugere o item para o cliente.
Empacotar itens grandes: tomando cuidado para colocar as garrafas grandes primeiro.
Empacotar itens médios: tomando cuidado para colocar os item congelados em sacolas térmicas.
Empacotar itens pequenos
BAGGER: Um Sistema ReativoConteúdo da MT
Suponha que a MT tenha o seguinte conhecimento sobre os itens que devem ser empacotados:
item tipo de embalagem tamanho congelado?Pão saco plástico médio nãomacarrão inst. pote pequeno nãoGranola caixa grande nãoSorvete pote médio simBatata Chips saco plástico médio nãoPepsi garrafa grande não
BAGGER: Um Sistema ReativoRegras
A memória de trabalho contém a asserção que identifica o passo Cada regra de BAGGER identifica o passo B1 é disparada somente quando o passo é checar
B1 Se Passo = checar empacotar(batata-chips)
não existe empacotar(pepsi)então pergunte ao cliente se ele gostaria de uma garrafa de Pepsi, em caso de
aceite, inserir( empacotar(pepsi) )
B2 muda o passo para empacotar-itens-grandes B2 Se Passo = checar
então apagar (Passo = checar) inserir (Passo = empacotar-itens-grandes)
B2 pode evitar que B1 faça o seu trabalho? Não se a estratégia de resolução de conflitos ordenar as regras
BAGGER: Um Sistema ReativoRegras
B3 e B4 são regras para empacotar-itens-grandesB3 Se Passo = empacotar-itens-grandes empacotar(X)
tamanho(X) = grandeembalagem(X) = garrafasacola-corrente(S)
quantidade-itens(S) < 6 então apagar( empacotar(X) ) inserir( em(X, S) )
B4 Se Passo = empacotar-itens-grandes empacotar(X) tamanho(X) = grande
sacola-corrente(S)quantidade-itens(S) < 6
então apagar( empacotar(X) ) inserir( em(X, S) )
BAGGER: Um Sistema ReativoRegras
B5 muda de sacolaB5 Se Passo = empacotar-itens-grandes empacotar(X)
tamanho(X) = grandepegar(Sacola-vazia)
então apagar( sacola-corrente(S) ) inserir( sacola-corrente(Sacola-vazia) )
B6 muda o passo para empacotar-itens-médiosB6 Se Passo = empacotar-itens-grandes
então apagar(Passo = empacotar itens grandes) inserir(Passo = empacotar-itens-médios)
BAGGER: Um Sistema ReativoRegras
B7 e B8 são regras para empacotar-itens-médiosB7 Se Passo = empacotar-itens-médios empacotar(X)
tamanho(X) = médio congelado(X)
pegar(Sacola-térmica)então apagar( empacotar(X) )
inserir( em(X, Sacola-térmica) )
B8 Se Passo = empacotar-itens-médios empacotar(X) tamanho(X) = médio
sacola-corrente(S)( vazia(S) ou para todo X pertencente a relação em(X, S),
tamanho(X) = médio )quantidade-itens(S) < 12
então apagar( empacotar(X) ) inserir( em(X, S) )
BAGGER: Um Sistema ReativoRegras
B9 muda de sacolaB9 Se Passo = empacotar-itens-médios empacotar(X)
tamanho(X) = médiopegar(Sacola-vazia)
então apagar( sacola-corrente(S) ) inserir( sacola-corrente(Sacola-vazia) )
B10 muda o passo para empacotar-itens-pequenosB10 Se Passo = empacotar-itens-médios
então apagar(Passo = empacotar-itens-médios) inserir(Passo = empacotar-itens-pequenos)
BAGGER: Um Sistema ReativoRegras
B11 empacota itens pequenosB11 Se Passo = empacotar-itens-pequenos empacotar(X)
tamanho(X) = pequenosacola-corrente(S)( vazia(S) ou
para todo X pertencente a relação em(X, S), tamanho(X) = pequeno)
quantidade-itens(Sacola-corrente) < 18 então apagar( empacotar(X) )
inserir( em(X, S) ) B12 muda de sacola
B12 Se Passo = empacotar-itens-pequenos empacotar(X)
tamanho(X) = pequenopegar(Sacola-vazia)
então apagar( sacola-corrente(S) )inserir( sacola-corrente(Sacola-vazia) )
BAGGER: Um Sistema ReativoRegras
B13 termina o empacotamentoB13 Se Passo = empacotar-itens-pequenos então apagar(Passo = empacotar-itens-pequenos) inserir(Passo = terminado)
BAGGER: Um Sistema ReativoConteúdo da MT
Suponha que a MT tenha o seguinte conhecimento sobre os o passo, a sacola corrente e sobre os itens que devem ser empacotados:
Passo = checar sacola-corrente(s1) empacotar(pão) empacotar(macarrão-instantâneo) empacotar(granola) empacotar(sorvete) empacotar(batata-chips)
BAGGER: Um Sistema ReativoFuncionamento
1º Ciclo: Regras habilitadas: B1 e B2 Regras disparadas: B1 (pela ordem) – sugerir ao cliente Nova MT: (supondo que o cliente aceitou a sugestão da Pepsi)
Passo = checar sacola-corrente(s1) empacotar(pão) empacotar(macarrão-instantâneo) empacotar(granola) empacotar(sorvete) empacotar(batata-chips) empacotar(pepsi)
BAGGER: Um Sistema ReativoFuncionamento
2º Ciclo: Regras habilitadas: B2 Regras disparadas: B2 – mudar o passo Nova MT:
sacola-corrente(s1) empacotar(pão) empacotar(macarrão-instantâneo) empacotar(granola) empacotar(sorvete) empacotar(batata-chips) empacotar(pepsi) Passo = empacotar-itens-grandes
BAGGER: Um Sistema ReativoFuncionamento
3º Ciclo: Regras habilitadas: B3, B4, B5 e B6 Regras disparadas: B3 (pela ordem) – empacotar garrafas primeiro
Unificação = {X/pepsi} Nova MT:
sacola-corrente(s1) empacotar(pão) empacotar(macarrão-instantâneo) empacotar(granola) empacotar(sorvete) empacotar(batata-chips) Passo = empacotar-itens-grandes em(pepsi, s1)
BAGGER: Um Sistema ReativoFuncionamento
4º Ciclo: Regras habilitadas: B4, B5 e B6 Regras disparadas: B4 (pela ordem) – empacotar outros itens
grandes Unificação = {X/granola}
Nova MT: sacola-corrente(s1) empacotar(pão) empacotar(macarrão-instantâneo) empacotar(sorvete) empacotar(batata-chips) Passo = empacotar-itens-grandes em(pepsi, s1) em(granola, s1)
BAGGER: Um Sistema ReativoFuncionamento
5º Ciclo: Regras habilitadas: B6 Regras disparadas: B6 – mudar o passo Nova MT:
sacola-corrente(s1) empacotar(pão) empacotar(macarrão-instantâneo) empacotar(sorvete) empacotar(batata-chips) em(pepsi, s1) em(granola, s1) Passo = empacotar-itens-médios
BAGGER: Um Sistema ReativoFuncionamento
6º Ciclo: Regras habilitadas: B7, B8, B9, B10 Regras disparadas: B7 (pela ordem) – empacotar itens congelados
primeiro Unificação {X/sorvete, Sacola-térmica/st1}
Nova MT: sacola-corrente(s1) empacotar(pão) empacotar(macarrão-instantâneo) empacotar(batata-chips) em(pepsi, s1) em(granola, s1) Passo = empacotar-itens-médios em(sorvete, st1)
BAGGER: Um Sistema ReativoFuncionamento
7º Ciclo: Regras habilitadas: B9, B10 Regras disparadas: B9 (pela ordem) – mudar de sacola
Unificação {X/pão, S/s1, Sacola-vazia/s2} Nova MT:
empacotar(pão) empacotar(macarrão-instantâneo) empacotar(batata-chips) em(pepsi, s1) em(granola, s1) Passo = empacotar-itens-médios em(sorvete, st1) sacola-corrente(s2)
BAGGER: Um Sistema ReativoFuncionamento
8º Ciclo: Regras habilitadas: B8, B9, B10 Regras disparadas: B8 (pela ordem) – empacotar outros itens
médios Unificação {X/pão, S/s2}
Nova MT: empacotar(macarrão-instantâneo) empacotar(batata-chips) em(pepsi, s1) em(granola, s1) Passo = empacotar-itens-médios em(sorvete, st1) sacola-corrente(s2) em(pão, s2)
BAGGER: Um Sistema ReativoFuncionamento
9º Ciclo: Regras habilitadas: B8, B9, B10 Regras disparadas: B8 (pela ordem) – empacotar outros itens
médios Unificação {X/batata-chips, S/s2}
Nova MT: empacotar(macarrão-instantâneo) em(pepsi, s1) em(granola, s1) Passo = empacotar-itens-médios em(sorvete, st1) sacola-corrente(s2) em(pão, s2) em(batata-chips, s2)
BAGGER: Um Sistema ReativoFuncionamento
10º Ciclo: Regras habilitadas: B10 Regras disparadas: B10 – mudar o passo Nova MT:
empacotar(macarrão-instantâneo) em(pepsi, s1) em(granola, s1) em(sorvete, st1) sacola-corrente(s2) em(pão, s2) em(batata-chips, s2) Passo = empacotar-itens-pequenos
BAGGER: Um Sistema ReativoFuncionamento
11º Ciclo: Regras habilitadas: B12, B13 Regras disparadas: B12 (pela ordem) – mudar a sacola
Unificação = {X/macarrão-instantâneo, Sacola-vazia/s3, S/s2} Nova MT:
empacotar(macarrão-instantâneo) em(pepsi, s1) em(granola, s1) em(sorvete, st1) em(pão, s2) em(batata-chips, s2) Passo = empacotar-itens-pequenos sacola-corrente(s3)
BAGGER: Um Sistema ReativoFuncionamento
12º Ciclo: Regras habilitadas: B11, B12, B13 Regras disparadas: B11 (pela ordem) – empacotar itens pequenos
Unificação = {X/macarrão-instantâneo, S/s3} Nova MT:
em(pepsi, s1) em(granola, s1) em(sorvete, st1) em(pão, s2) em(batata-chips, s2) Passo = empacotar-itens-pequenos sacola-corrente(s3) em(macarrão-instantâneo, s3)
BAGGER: Um Sistema ReativoFuncionamento
13º Ciclo: Regras habilitadas: B13 Regras disparadas: B13 - terminar Nova MT:
em(pepsi, s1) em(granola, s1) em(sorvete, st1) em(pão, s2) em(batata-chips, s2) sacola-corrente(s3) em(macarrão-instantâneo, s3) Passo = terminado
BAGGER: Um Sistema ReativoFuncionamento
14º Ciclo: Regras habilitadas: nenhuma Regras disparadas: nenhuma MT Final:
em(pepsi, s1) em(granola, s1) em(sorvete, st1) em(pão, s2) em(batata-chips, s2) sacola-corrente(s3) em(macarrão-instantâneo, s3) Passo = terminado
Fase de Casamento (match)
Casamento O sistema, em cada ciclo, computa o subconjunto de regras no
qual os antecedentes são satisfeitos pelo conteúdo atual da memória de trabalho
Exemplo da fase de casamentoCavalos de corrida
Conteúdo da MT: Comet é-um cavalo Pracer é-um cavalo Comet é-pai-de Dasher Comet é-pai-de Pracer Pracer é rápido Dasher é-pai-de Thunder Thunder é rápido Thunder é-um cavalo Dasher é-um cavalo
Regra para estabelecer se um cavalo é valioso:se ?x é-um cavalo
?x é-pai-de ?y?y é rápido
então ?x é valioso
Exemplo da fase de casamento com encadeamento para frente
x Comet Pracerx Thunderx Dasherx
?x é-um cavalo
Exemplo da fase de casamento com encadeamento para frente
x Comet Pracerx Thunderx Dasherx
y Dasherx Comety Dasherx Comet
?x é-pai-de ?y
y Pracerx Comet
?x é-um cavalo
Exemplo da fase de casamento com encadeamento para frente
x Comet Pracerx Thunderx Dasherx
y Dasherx Comety Dasherx Comet
?y é rápidox
y Pracerx Comet
?x é-pai-de ?y
?x é-um cavalo
Exemplo da fase de casamento com encadeamento para frente
x Comet Pracerx Thunderx Dasherx
y Dasherx Comety Dasherx Comet
x
y Pracerx Comet
y Pracerx Comet
?y é rápido
?x é-pai-de ?y
?x é-um cavalo
Exemplo da fase de casamento com encadeamento para frente
x Comet Pracerx Thunderx Dasherx
y Dasherx Comet
y Pracerx Comet
y Pracerx Comet
y Dasherx Comet
x
x ?y é rápido
?x é-pai-de ?y
?x é-um cavalo
Exemplo da fase de casamento com encadeamento para frente
x Comet Pracerx Thunderx Dasherx
y Dasherx Comet
y Pracerx Comet
y Pracerx Comet
y Dasherx Comet
x x
x ?y é rápido
?x é-pai-de ?y
?x é-um cavalo
Exemplo da fase de casamento com encadeamento para frente
x Comet Pracerx Thunderx Dasherx
y Dasherx Comet
y Pracerx Comet
y Thunderx Dasher
y Pracerx Comet
y Dasherx Comet
x x
x ?y é rápido
?x é-pai-de ?y
?x é-um cavalo
Exemplo da fase de casamento com encadeamento para frente
x Comet Pracerx Thunderx Dasherx
y Dasherx Comet
y Pracerx Comet
y Thunderx Dasher
y Pracerx Comet
y Dasherx Comet
y Thunderx Dasher
x x
x ?y é rápido
?x é-pai-de ?y
?x é-um cavalo
Exemplo da fase de casamento como operações relacionais Vamos pensar na MT como uma relação:
Primeira Segunda TerceiraComet É-um CavaloPracer É-um CavaloComet É-pai-de DasherComet É-pai-de PracerPracer É RápidoDasher É-pai-de ThunderThunder É RápidoThunder É-um CavaloDasher É-um Cavalo
Exemplo da fase de casamento como operações relacionais
Para determinar os valores de ?x e?y para a regra dos cavalos valiosos Vamos determinar quais os registros da relação que casam com o
primeiro antecedente da regra (?x é-um cavalo) Isso implica em selecionar os registros nos quais a segunda
coluna é igual a é-um e a terceira coluna é igual a cavalo ou SELECT * FROM MT WHERE segunda = “é-um” AND terceira =
“cavalo” Temos como resultado:
Primeira Segunda TerceiraComet É-um CavaloPracer É-um CavaloThunder É-um CavaloDasher É-um Cavalo
Exemplo da fase de casamento como operações relacionais
Queremos saber quais valores casam com ?x, desta forma estamos interessados nos valores da primeira coluna
Isto implica em fazer uma projeção sobre a primeira coluna da relação resultante da seleção
SELECT primeira FROM MT
Poderíamos ter feito diretamente: SELECT primeira FROM MT WHERE segunda=”é-um” AND terceira=”cavalo”
PrimeiraCometPracer Renomeando ==>ThunderDasher
A1 XCometPracer
ThunderDasher
Exemplo da fase de casamento como operações relacionais
Vamos determinar quais os registros da relação que casam com o segundo antecedente da regra (?x é-pai-de ?y) SELECT primeira, terceira FROM MT WHERE segunda = “é-pai-
de” Temos como resultado:
A2 X YComet DasherComet PracerDasher Thunder
Exemplo da fase de casamento como operações relacionais
Vamos determinar quais os registros da relação que casam com o terceiro antecedente da regra (?y é rápido) SELECT primeira FROM MT WHERE segunda = “é” AND
terceira=”rápido” Temos como resultado:
A3 YPracer
Thunder
Exemplo da fase de casamento como operações relacionais
Agora temos as seguinte relações:
E queremos saber quais os valores de ?x que satisfazem o primeiro e o segundo antecedentes Isto é equivalente a um JOIN entre a relação A1 e A2, resultando
em:
A1 XCometPracer
ThunderDasher
A2 X YComet DasherComet PracerDasher Thunder
A3 YPracer
Thunder
B1 X YComet DasherComet PracerDasher Thunder
Exemplo da fase de casamento como operações relacionais
Agora temos as seguinte relações:
E queremos saber quais os valores de ?Y que satisfazem o segundo e terceiro antecedentes Isto é equivalente a um JOIN entre a relação A3 e B1, resultando
em:
B1 X YComet DasherComet PracerDasher Thunder
A3 YPracer
Thunder
B2 X YComet PracerDasher Thunder
Exemplo da fase de casamento como operações relacionais
Como o consequente da regra diz respeito somente a ?x:
Isto significa que tanto Comet quanto Dasher são valiosos. Em sistemas dedutivos, as duas instanciações de ?x podem ser
usadas Em sistemas reativos, o procedimento de resolução de conflitos
selecionará uma ação
B2 XCometDasher
Fase de casamento como operações relacionais
Problema: este procedimento ocupa muita computação
Se a regra tem n antecedentes, precisamos de:
n selects, n projects para produzir as relações A +
n-1 joins e n-1 projects para produzir as relações B
Se existir m regras, a cada nova asserção, teremos: mn selects, m(2n-1) projects, m(n-1) joins – que são caros
Solução: Algoritmo de Rete Os JOINs são executados entre uma linha de uma relação e a
outra relação, o que diminui o custo de JOINs grandes
Fase de casamento: Algoritmo de Rete
Inventado por Dr. Charles Forgy em 1979
Duas partes: Tempo de Compilação
Descreve como gerar uma rede de discriminação para as regras da base que possa auxiliar a fase de casamento
A rede de discriminação é utilizada com um “filtro de dados”
Tempo de Execução A rede é utilizada para unificar a memória de trabalho com as regras
da base de forma mais eficiente
Fase de casamento: Algoritmo de ReteConstrução da Rede de Rete
Para cada antecedente que aparece no conjunto de regras, crie uma operação de SELECT que examina novas asserções
Para cada regraPara cada antecedente
Crie um nó alfa e anexe a ele a operação de SELECT correspondente (já criada)
Para cada nó alfa exceto o primeiroCrie um nó beta e anexe a operação de JOIN correspondenteSe o nó beta é o primeiro anexe a ele o primeiro e segundo nós alfaCaso contrário, anexe ao nó beta o nó alfa correspondente e o nó beta anterior
Anexe uma a operação de PROJECT correspondente ao nó beta final
SELECT primeira FROM MT WHERE segunda = “é-um” AND terceira = “cavalo”SELECT primeira, terceira FROM MT WHERE segunda = “é-pai-de”
SELECT primeira FROM MT WHERE segunda = “é” AND terceira = “rápido”
X
X Y YX
X Y
X Y
A1 A2 A3
B12
B23Rede de rete para o problema dos cavalos valiosos
Fase de casamento: Algoritmo de ReteUso da Rede de Rete como filtro
Para cada asserção, filtre a asserção pelas operações de SELECT, passando a asserção através da rede para os nós alfa associados
Para cada nó alfa que recebe uma asserção, use a operação de JOIN passando a asserção através da rede para o nó beta associado
Para cada nó beta que recebe uma nova asserção, use a operação de JOIN para propagar as mudanças através da rede para os outros nós beta associados a ele
Para cada regra, use a operação de PROJECT para isolar o valor associado à variável correspondente ao consequente da regra
SELECT primeira FROM MT WHERE segunda = “é-um” AND terceira = “cavalo”SELECT primeira, terceira FROM MT WHERE segunda = “é-pai-de”
SELECT primeira FROM MT WHERE segunda = “é” AND terceira = “rápido”
X
X Y YXComet
X Y
X Y
A1 A2 A3
B12
B23Funcionamento da Rede de rete para o problema dos cavalos valiosos
Comet é-um cavalo
SELECT primeira FROM MT WHERE segunda = “é-um” AND terceira = “cavalo”SELECT primeira, terceira FROM MT WHERE segunda = “é-pai-de”
SELECT primeira FROM MT WHERE segunda = “é” AND terceira = “rápido”
X
X Y YXCometPracer
X Y
X Y
A1 A2 A3
B12
B23Funcionamento da Rede de rete para o problema dos cavalos valiosos
Pracer é-um cavalo
SELECT primeira FROM MT WHERE segunda = “é-um” AND terceira = “cavalo”SELECT primeira, terceira FROM MT WHERE segunda = “é-pai-de”
SELECT primeira FROM MT WHERE segunda = “é” AND terceira = “rápido”
X
X YComet Dasher
YXCometPracer
X YComet Dasher
X Y
A1 A2 A3
B12
B23Funcionamento da Rede de rete para o problema dos cavalos valiosos
Comet é-pai-de Dasher
SELECT primeira FROM MT WHERE segunda = “é-um” AND terceira = “cavalo”SELECT primeira, terceira FROM MT WHERE segunda = “é-pai-de”
SELECT primeira FROM MT WHERE segunda = “é” AND terceira = “rápido”
X
X YComet DasherComet Pracer
YXCometPracer
X YComet DasherComet Pracer
X Y
A1 A2 A3
B12
B23Funcionamento da Rede de rete para o problema dos cavalos valiosos
Comet é-pai-de Pracer
SELECT primeira FROM MT WHERE segunda = “é-um” AND terceira = “cavalo”SELECT primeira, terceira FROM MT WHERE segunda = “é-pai-de”
SELECT primeira FROM MT WHERE segunda = “é” AND terceira = “rápido”
XComet
X YComet DasherComet Pracer
YPracer
XCometPracer
X YComet DasherComet Pracer
X YComet Pracer
A1 A2 A3
B12
B23Funcionamento da Rede de rete para o problema dos cavalos valiosos
Pracer é rápido
SELECT primeira FROM MT WHERE segunda = “é-um” AND terceira = “cavalo”SELECT primeira, terceira FROM MT WHERE segunda = “é-pai-de”
SELECT primeira FROM MT WHERE segunda = “é” AND terceira = “rápido”
XComet
X YComet DasherComet PracerDasher Thunder
YPracer
XCometPracer
X YComet DasherComet Pracer
X YComet Pracer
A1 A2 A3
B12
B23Funcionamento da Rede de rete para o problema dos cavalos valiosos
Dasher é-pai-de Thunder
SELECT primeira FROM MT WHERE segunda = “é-um” AND terceira = “cavalo”SELECT primeira, terceira FROM MT WHERE segunda = “é-pai-de”
SELECT primeira FROM MT WHERE segunda = “é” AND terceira = “rápido”
XComet
X YComet DasherComet PracerDasher Thunder
YPracer
Thunder
XCometPracer
X YComet DasherComet Pracer
X YComet Pracer
A1 A2 A3
B12
B23Funcionamento da Rede de rete para o problema dos cavalos valiosos
Thunder é rápido
SELECT primeira FROM MT WHERE segunda = “é-um” AND terceira = “cavalo”SELECT primeira, terceira FROM MT WHERE segunda = “é-pai-de”
SELECT primeira FROM MT WHERE segunda = “é” AND terceira = “rápido”
XComet
X YComet DasherComet PracerDasher Thunder
YPracer
Thunder
XCometPracer
Thunder
X YComet DasherComet Pracer
X YComet Pracer
A1 A2 A3
B12
B23Funcionamento da Rede de rete para o problema dos cavalos valiosos
Thunder é-um cavalo
SELECT primeira FROM MT WHERE segunda = “é-um” AND terceira = “cavalo”SELECT primeira, terceira FROM MT WHERE segunda = “é-pai-de”
SELECT primeira FROM MT WHERE segunda = “é” AND terceira = “rápido”
XCometDasher
X YComet DasherComet PracerDasher Thunder
YPracer
Thunder
XCometPracer
ThunderDasher
X YComet DasherComet PracerDasher Thunder
X YComet PracerDasher Thunder
A1 A2 A3
B12
B23Funcionamento da Rede de rete para o problema dos cavalos valiosos
Dasher é-um cavalo
SELECT primeira FROM MT WHERE segunda = “é-um” AND terceira = “cavalo”SELECT primeira, terceira FROM MT WHERE segunda = “é-pai-de”
SELECT primeira FROM MT WHERE segunda = “é” AND terceira = “rápido”
XCometDasher
X YComet DasherComet PracerDasher Thunder
YPracer
Thunder
XCometPracer
ThunderDasher
X YComet DasherComet PracerDasher Thunder
X YComet PracerDasher Thunder
A1 A2 A3
B12
B23Funcionamento da Rede de rete para o problema dos cavalos valiosos
Dasher é-um cavalo
Algoritmo de Rete
Fase de Resolução de conflitos
Estratégias para resolução de conflitos entre as regras disparadas Ordenação das regras: Ordenar as regras em uma lista de
prioridade, executar aquela com maior prioridade Ordenação de tamanho: executar a regra tem o maior número
de antecedentes Ordenação de dados: Ordenar as asserções por prioridade,
executar a regra que casa com a asserção de maior prioridade Refração: não executar a mesma regra com os mesmos
argumentos duas vezes Recência: dar preferência as regras que se referem a elementos
da MT criados recentemente (simula o foco de atenção do discurso)
Especificidade: dar preferência as regras que são mais específicas
Outras
Exercício
Mostre os quatro (4) primeiros ciclos de operação do sistema de produção a seguir (se possível) listando: i) o Ciclo; ii) as Regras satisfeitas; ii) a Regra escolhida em cada ciclo e
iv) a nova memória de trabalho. ?x, ?y e ?z são variáveis e os outros termos são constantes. A estratégia de resolução de conflitos:
Escolher a regra com o maior número de precondições Nenhuma regra pode ser usada mais de uma vez com o mesmo
conjunto de variáveis atribuídas Se ainda houver conflito entre as regras, a última regra satisfeita
deve ser aplicada. ¬P(x) significa que P(x) não pode estar na MT
Exercício
Regras:(R1) IF P(?x, ?y) Q(?x, a, ∧ ?z) ∧ ¬Q(?z, a, ?z)
THEN assert R(?x) retract Q(?x, a, ?z)
(R2) IF R(?x) ∧ Q(?x, ?y, ?z) THEN retract R(?x)
(R3) IF P(f(?x), ?y) ∧ ?x ≤ ?y ∧ Q(f(?w), ?w, f(?z)) ∧ ?y ≤ ?z THEN print SUCCESS!
(R4) IF R(?x) THEN assert Q(f(?x), ?x, f(?x))
Memoria de Trabalho inicial:
P(f(1), 2) Q(f(1), a, f(1)) R(f(1))P(3, f(4)) Q(4, a, 3)P(4, 4)
top related