curso inteligência artificial - parte 2 -

Inteligência Artificial (parte II) Ronaldo F. Ramos, Dr ronaldo@cefet-ce.br

Adaptado de : aima.cs.berkeley.edu

Agentes Lógicos

Roteiro

! Agentes Baseados em Conhecimento ! O mundo de Wumpus ! Lógica em Geral – Modelos e implicações ! Lógica proposicional (booleana). ! Equivalência, validade e satisfatibilidade ! Regras de Inferência e prova de teoremas

!  Encadeamento para frente !  Encadeamento para trás !  Resolução

Bases de conhecimento.

!  Base de conhecimento = conjunto de sentenças em uma linguagem formal.

!  Abordagem declarativa para construção de agentes (ou outra coisa) !  Informar ao mesmo apenas o que ele precisa saber

!  Então ele pode perguntar sozinho o que ele fazer. As respostas virão da base de conhecimento

!  Agentes podem ser visualizados ao nível do conhecimento i. e., o que eles sabem não importando como foram implementados, ou ao nivel de implementação, i. e., estruturas de dados na KB e os algoritmos que os manipulam.

Máquina de Inferência

Base de conhecimento (KB)

Algoritmo independente de domínio Conteúdo dependente do domínio

Um agente baseado em conhecimento

!  O agente deve ser capaz de: !  Representar estados, ações, etc !  Incorporar novas percepções !  Atualizar a representação interna do mundo !  Deduzir propriedades ocultas do mundo !  Deduzir ações apropriadas.

função KB-AGENT (percepção) retorna uma ação variáveis estáticas: KB, a base de conhecimento t, um contador inicialmente 0 indicando tempo TELL(KB,CRIAR-SENTENÇA-DE-PERCEPÇÃO(percepção,t)) ação <-- ASK(KB, CRIAR-CONSULTA-DE-AÇÃO(t)) TELL(KB,CRIAR-SENTENÇA-DE-AÇÃO(ação,t)) t <-- t + 1 retorna ação

Mundo de Wumpus - Descrição PEAS !  Medida de desempenho

!  +1000 se pegar ouro, -1000 se cair no poço ou for devorado pelo wumpus

!  -1 ação executada, -10 uso da flecha !  Ambiente

!  Malha de 4 x 4 o começa em 1,1 !  Quadrados adjacentes ao wumpus fedem !  Quadrados adjacentes a um poço têm brisa !  Brilho sse tem o ouro !  Um tiro pode matar o wumpus se vc está lutando com ele. !  O agente só possui uma flecha !  Agente pode AGARRAR o ouro se estiver no mesmo quadrado !  Agente pode SOLTAR o ouro no quadrado atual

!  Sensores: Fedor, Brisa, Brilho, Impacto, Grito de Morte !  Efetuadores: Esquerda, Direita, Em frente, Baixo, Agarra,

Solta, Atira

Caracterização do mundo ! Completamente observável: Não – somente

percepção local. ! Determinístico: Sim – As conseqüências são

perfeitamente especificadas. ! Episódico: Não – Seqüencial ao nível das

ações. ! Estático: Sim – Wumpus e os poços não

movem. ! Discreto: Sim ! Único Agente: Sim – Wumpus é

essencialmente uma criatura natural

Explorando o mundo de Wumpus

Lógica em geral !  Lógica é uma linguagem formal para representar informações a

partir das quais podem ser retiradas conclusões. !  Regras de sintaxe definem as sentenças na linguagem !  A Semântica define o significado das sentenças

!  i. e., define a verdade de uma sentença em um mundo.

!  E.g., a linguagem da aritmética

!  x+2 ≥ y é uma sentença; x2+y > {} não é uma sentença !  x+2 ≥ y é verdade sse o número x+2 não é menor que o número y !  x+2 ≥ y é verdade em um mundo onde x = 7, y = 1 !  x+2 ≥ y é falso em um mundo onde x = 0, y = 6

Consequência Lógica !  Consequência lógica significa que uma coisa segue,

decorre logicamente de outra. KB ╞ α

!  Uma base de conhecimento KB tem como consequência lógica uma sentença α sse α é verdade em todos os mundos onde KB é verdade

!  E.g., A base de conhecimento KB contendo “Os gigantes

ganharam” e “Os Vermelhos Ganharam” tem como conseqüência lógica “Ou os gigantes ganharam ou os Vermelhos Ganharam”

!  E.g., x+y = 4 tem como conseqüência 4 = x+y !  Conseqüência lógica é um relacionamento entre sentenças

(sintaxe) baseada na semântica.

Modelos !  Lógicos normalmente raciocinam em termos de modelos, os

quais são mundos formalmente estruturados com relação a qual verdade pode ser avaliada.

!  Dizemos que m é um modelo de α se α é verdade em m !  M(α) é o conjunto de todos os modelos de α !  Consequentemente KB ╞ α sse M(KB) ⊆ M(α)

!  E.g. KB = Gigantes ganharam e Vermelhos ganharam

α = Gigantes ganharam

Conseqüência lógica no mundo de wumpus

Situação depois de detectar nada em [1,1], mover para direita, brisa em [2,1]

Considerar possíveis modelos

para a KB assumindo somente a existência de poços.

3 escolhas booleanas ⇒ 8

modelos possíveis

Modelos Wumpus

! KB = Regras do mundo wumpus + observações

Modelos Wumpus

!  KB = Regras do Mundo Wumpus + observações !  α1 = "[1,2] é seguro", KB ╞ α1, provado por checagem do

modelo

Modelos Wumpus

! KB = Regras do Mundo Wumpus + observações

Modelos Wumpus

! KB = Regras do Mundo Wumpus + observações

! α2 = "[2,2] é seguro", KB ╞ α2

Inferência !  KB ├i α = Sentença α pode ser derivada de KB pelo

procedimento i !  Consistência: i é consistente se sempre que KB ├i α,

é também verdade que KB╞ α !  Completeza: i é completo se sempre que KB╞ α,

também é verdade que KB ├i α

!  A “Lógica de Primeira Ordem” é expressiva o suficiente para expressar o que for de interesse e para isto sempre existe um procedimento consistente e completo.

!  Ou seja, o procedimento reponderá qualquer questão cuja resposta decorre do que é conhecido pela KB.

Lógica proposicional : Sintaxe

!  A lógica proposicional é a “lógica” mais simples – Ilustra idéias básicas

!  Símbolos proposicionais P1, P2 etc são sentenças

!  Se S é uma setença , ¬S é uma sentença (negação) !  Se S1 e S2 são sentenças, S1 ∧ S2 é uma sentença(conjunção) !  Se S1 e S2 são sentenças, S1 ∨ S2 é uma sentença(disjunção) !  Se S1 e S2 são sentenças, S1 ⇒ S2 é uma sentença(implicação) !  Se S1 e S2 são sentenças, S1 ⇔ S2 é uma sentença(bicondicional)

Lógica Proposicional: Semântica Cada modelo especifica a verdade ou falsidade para cada proposição.

Ex. P1,2 P2,2 P3,1 falso verdade falso

Com estes símbolos podem ser enumerados automaticamente 8 modelos possíveis.

Regras para a avaliação de verdade com relação a um modelo m:

¬S é verdade sse S is falso S1 ∧ S2 é verdade sse S1 é verdade e S2 é verdade S1 ∨ S2 é verdade sse S1 é verdade ou S2 é verdade S1 ⇒ S2 é verdade sse S1 é falso ou S2 é verdade i.e., é falso sse S1 is verdade e S2 is falso S1 ⇔ S2 é verdade sse S1⇒S2 é verdade e S2⇒S1 é verdade

Um processo recursivo simples avalia uma sentença: ¬P1,2 ∧ (P2,2 ∨ P3,1) = verdade ∧ (verdade ∨ falso) = verdade ∧ verdade = verdade

Tabela de Verdade para Conectivos

P Q ~P P ^ Q P v Q P" Q P#Q

Falso Falso Verdade Falso Falso Verdade Verdade

Falso Verdade Verdade Falso Verdade Verdade Falso

Verdade Falso Falso Falso Verdade Falso Falso

Verdade Verdade Falso Verdade Verdade Verdade Verdade

Sentenças no mundo Wumpus Seja Pi,j verdade se existir um poço em [i, j]. Seja Bi,j verdade se existir uma brisa em [i, j]. - Não existe poço em [1,1]

R1: ¬ P1,1

- Poços ocasionam brisa em quadros adjacentes R2: B1,1 ⇔ (P1,2 ∨ P2,1)

R3: B2,1 ⇔ (P1,1 ∨ P2,2 ∨ P3,1)

- Não existe brisa em [1,1] porém existe em [2,1]

R4: ¬B1,1

R5: B2,1

Tabela de Verdade p/ Inferência

B1,1 B2,1 P1,1 P1,2 P2,1 P2,2 P3,1 KB α1 F F F F F F F F V F F F F F F V F V ... ... ... ... ... ... ... ... ... F V F F F F F F V F V F F F F V V V F V F F F V F V V F V F F F V V V V F V F F V F F F V ... ... ... ... ... ... ... ... ... V V V V F V V F F

Lembrete: KB = R1 ^ R2 ^ R3 ^ R4 ^ R5

Inferência por enumeração !  Enumeração em profundidade preserva verdade e é completa !  Para n símbolos, complexidade de tempo é O(2n),

complexidade de espaço O(n)

Função CONSEQUENCIA-LOGICA-TV?(KB,A) retorna V ou F entradas : KB, a base de conhecimento, sentença em lógica proposicional α, a consulta, uma sentença em lógica proposicional simbolos <- uma lista de simbolos em Logica Proposicional retornar VERIFICAR-TODOS-TV(KB,α,simbolos,[])

--------------------------------------------------------------------------------- Função VERIFICAR-TODOS-TV(KB, α,simbolos, modelo) retorna V ou F se VAZIO(simbolos) então se VERDADE-LP(BC,modelo) então retornar VERDADEIRO-LP(α,modelo) senão retornar V senão faça P <- PRIMEIRO(simbolos); restante <- RESTO(simbolos) retornar VERIFICAR-TODOS-TV(KB,α,restante,ESTENDER(P,V,modelo)) e VERIFICAR-TODOS-TV(KB,α,restante,ESTENDER(P,F,modelo))

Equivalência Lógica •  Duas sentenças são logicamente equivalentes sse elas são

verdade nos mesmos modelos α ≡ ß sse α╞ β e β╞ α

Validade e satisfatibilidade Uma senteça é válida se ela é verdade em todos os modelos,

ex., Verdade, A ∨¬A, A ⇒ A, (A ∧ (A ⇒ B)) ⇒ B

Validade é ligada a inferência via Teorema da dedução:

KB ╞ α sse (KB ⇒ α) é válida Uma sentença é satisfatível se ela é verdade em algum modelo

ex, A ∨ B, C

Uma sentença é não satisfatível se ela não é verdade em nenhum modelo e.g., A∧¬A

Satisfatibilidade é conectada a inferência pelo seguinte:

KB ╞ α sse (KB ∧¬α) é não satisfatível

Métodos de prova !  Grosso modo, métodos de prova são divididos em

dois tipos:

!  Aplicação de regras de inferência !  Legitimar a geração de novas sentenças a partir das velhas !  Prova = uma sequência de aplicações de regras de inferência.

Pode usar regras de inferência como operadores em um algoritmo padrão de busca

!  Normalmente requer a transformação de sentenças em uma forma normal

!  Checagem de modelo

!  Enumeração de tabelas de Verdade (exponencial em n) !  Backtraking aperfeiçoado !  Busca heurística no espaço de modelos (Preserva a verdade

porém é incompleto)

Resolução Forma Normal Conjuntiva (FNC) Conjunção de Disjunções de cláusulas literais

Ex (A ∨ ¬B) ∧ (B ∨ ¬C ∨ ¬D)

!  Regra de Inferência da Resolução(para FNC):

li ∨… ∨ lk, m1 ∨ … ∨ mn

li ∨ … ∨ li-1 ∨ li+1 ∨ … ∨ lk ∨ m1 ∨ … ∨ mj-1 ∨ mj+1 ∨... ∨ mn

onde li e mj são literais complementares.

Ex., P1,1 ∨ P3,1, ¬P1,1 ∨ P2,2

P3,1 ∨ P2,2

!  A resolução preserva a verdade (consistente) e é completa para lógica proposicional

Conversão para FNC (Forma normal conjuntiva)

B1,1 ⇔ (P1,2 ∨ P2,1) 1.Eliminar ⇔, substituindo α ⇔ β por (α ⇒ β)∧(β ⇒ α).

(B1,1 ⇒ (P1,2 ∨ P2,1)) ∧ ((P1,2 ∨ P2,1) ⇒ B1,1)

2. Eliminar ⇒, Substituindo α ⇒ β por ¬α∨ β.

(¬B1,1 ∨ P1,2 ∨ P2,1) ∧ (¬(P1,2 ∨ P2,1) ∨ B1,1)

3. Mover ¬ para dentro usando a lei De Morgan:

(¬B1,1 ∨ P1,2 ∨ P2,1) ∧ ((¬P1,2 ∧ ¬P2,1) ∨ B1,1)

4. Aplicando a regra da distributividade de ∧ sobre ∨:

(¬B1,1 ∨ P1,2 ∨ P2,1) ∧ (¬P1,2 ∨ B1,1) ∧ (¬P2,1 ∨ B1,1)

Algoritmo de Resolução !  Prova por contradição, i.e., mostra-se que KB∧¬α é não-

satisfatível

Função Resolução-LP(KB,α) retorna V ou F entradas: KB, a base de conhecimento (setença LP)

α, a consulta, uma consulta em LP cláusulas <- conjunto de cláusulas FNC (KB ^ ~α)

nova <- {} repita para cada ci,cj em cláusulas faça resolventes <- RESOLVER-LP(ci,cj) se resolventes contém cláusula vazia então retornar V nova <- nova U resolventes se nova ⊆ cláusulas então retornar F clausulas <- cláusulas U nova

Exemplo

KB = (B1,1 ⇔ (P1,2∨ P2,1)) ∧¬ B1,1 α = ¬P1,2

Encadeamento pra frente e pra trás (Forward and backward chaining)

!  Forma de Horn (restrita) KB = conjunção de cláusulas de Horn

!  Cláusula de Horn = !  Símbolo de proposição; ou !  (conjunção de simbolos ⇒ simbolo) !  De outra forma seria uma disjunção onde um dos disjuntos é

positivo(cabeça) !  Ex., C ∧ (B ⇒ A) ∧ (C ∧ D ⇒ B)

!  Modus Ponens (para Forma de Horn): completo para Horn KBs α1, … ,αn, α1 ∧ … ∧ αn ⇒ β

β !  Pode ser utilizada com encadeamento pra frente ou prá trás. !  Algoritmos naturais e rodam em tempo linear

Encadeamento pra frente

!  Idéia básica: executar todas as regras cujas premissas são satisfeitas pela KB,

!  Adicionar as conclusões à KB, até que a questão seja encontrada

Algoritmo de encadeamento pra frente

!  Encadeamento pra frente é consistente e completo para bases de conhecimento de Horn

função PL-FC-CONSEQUENCIA-LOG(KB,q) retornar V ou F variáveis locais: cont, tabela, indexada por cláusula, inicialmente o número de premissas

inferido, tabela, indexada por simbolo, todos inicialmente falsos agenda, lista de simbolos, inicialmente todos verdade

Enquanto agenda é não vazia faça p $ POP(agenda) a menos que inferido[p] faça inferido[p] $ V

para cada cláusula c em cuja premisa p aparece faça decremente cont[c] se cont[c] == 0 então faça se cabeça[c] == q então retornar V push(cabeça[c],agenda)

retornar F

Exemplo

Encadeamento pra frente

Completo e consistente

Encadeamento pra Trás(ET) (Backward chaining)

Idéia: como a análise a partir de uma questão (q) colocada sobre a KB a fim de prová-la.

!  Checa se q ja é conhecida, ou !  Prova por ET todas as premissas de qualquer regra

concluindo q

Para Evitar Loops: Checar se a nova sub-meta já se encontra na pilha de metas

Evitar Trabalho Repetido: checa se cada nova sub-

meta 1.  Já foi provada verdadeira, ou 2.  Já foi provada falsa (sem sucesso)

Exemplo

Comparação Inicial !  EF é orientado a dados, automático e “cego”.

!  e.g., reconhecimento de objetos, decisões de rotina

!  Pode acabar fazendo muito processamento irrelevante para os objetivos.

!  ET é orientado a meta, mais apropriado para solução de problemas.

!  e.g., Onde estão as chaves? Como se tornar um PhD?

!  Complexidade da ET pode ser bem menor que linear em relação ao tamanho da base de conhecimento

Inferência proposicional efetiva

-  Duas famílias de algoritmos para inferência proposicional

!  Algoritmos completo com retrocesso

!  Algoritmo DPLL (Davis, Putnam, Logemann, Loveland)

!  Algoritmo de busca local incompleta !  WalkSAT algorithm

OBS: Usam checagem de modelo

O algoritmo DPLL Determina se uma sentença em lógica proposicional (FNC) é satisfatível.

Melhorias em relação à enumeração de tabelas de verdade.

1.  Termino Prematuro Uma cláusula é V se algum literal é V. Uma senteça é F se alguma cláusula é F.

2.  Heurística do Símbolo Puro

Símbolo Puro: Aparece sempre com o mesmo sinal em todas as cláusulas. ex. Nas seguintes cláusulas (A ∨ ¬B), (¬B ∨ ¬C), (C ∨ A), A e B são puros, C é

impuro. Fazer um símbolo literal puro V.

3.  Cláusula Heurística Unitária

1.  Apenas um literal na cláusula 2.  Este literal deve ser verdadeiro

O Algoritmo DPLL função DPLL-Satisfatível?(s) retorna V ou F

entrada: s, uma sentença em LP clausulas $ o conjunto de cláusulas na FNC de s símbolos $ lista dos símbolos proposicionais em s retornar DPLL(clausulas,símbolos,[])

------------------------------------------------------------------------ função DPLL(clausulas, simbolos, modelo) retorna V ou F se toda cláusula em cláusulas é V no modelo então retornar V se alguma cláusula em cláusulas é F no modelo então retornar F P,valor $SIMBOLO-PURO(símbolos,cláusulas,modelo) se P é não nulo então retorne DPLL(cláusulas,simbolos-P,[P=valor|modelo]) P,valor $ CLÁUSULA-UNITÁRIA(cláusula,modelo) se P é não nulo então retorne DPLL(cláusulas, símbolos-P,[P=valor|modelo]) P $ PRIMEIRO(símbolos); resto $ RESTO(símbolos) retornar DPLL(clásulas, resto, [P= V|modelo] ou DPLL(cláusulas, resto, [P= falso|modelo]

O Algoritmo WalkSAT !  Algoritmo de busca local incompleto. Subida da

encosta no espaço de atribuições completas !  Em cada iteração o o algoritmo escolhe uma cláusula

não satisfeita e um símbolo dessa cláusula para trocar. A forma de escolha do símbolo a trocar de valor é ela própria aleatória, podendo ser:

! ⇒ Utilizando a heurística “min-conflitos” minimizando o número de cláusulas insatisfeitas no passo seguinte

! ⇒Escolha aleatória do símbolo a trocar na cláusula

O algortimo WalkSAT função WALKSAT( cláusulas,p,inversoes_max) retorna modelo ou falha .... entradas: cláusulas, um conjunto de cláusulas

p, probabilidade de optar por realizar um movimento aleatório inversoes_max, número máximo de inversões permitidos antes de desistir

modelo $ atribuição aleatória de V/F aos símbolos nas cláusulas para i= 1 to inversoes_max do se modelo satisfaz cláusulas então retornar modelo cláusula $ a uma cláusula falsa no modelo selecionada aleatoriamente com probabilidade p inverter o valor de um símbolo selecionado

aleatoriamente da cláusula senão inverter qualquer símbolo que maximize o número de cláusulas

satisfeitas retornar falha

Propriedades do WalkSAT ♦ Incompleto ♦ Se uma proposição é insatisfazível então o algoritmo não termina: limita-se max flips... ♦ Algoritmos locais como o WalkSAT são mais eficazes quando se espera que uma solução exista ♦ Logo, pesquisa local não serve em geral para resolver o problema da conseqüência lógica ♦ Muito eficiente na prática...

Problema de difícil satisfatibilidade

! Considere as seguintes sentenças aleatórias na 3a FNC: (¬D ∨ ¬B ∨ C) ∧ (B ∨ ¬A ∨ ¬C) ∧ (¬C ∨ ¬B ∨ E) ∧ (E ∨ ¬D ∨ B) ∧ (B ∨ E ∨ ¬C)

m = número de cláusulas n = número de símbolos

!  Problemas difíceis a partir de m/n = 4.3 (ponto crítico)

Problemas de difícil satisfazibilidade

! Tempo mediano para 100 sentenças satisfatíveis aleatórias na 3a FNC, n = 50

Agentes de inferência no mundo Wumpus

Usando a lógica proposicional

¬P1,1

¬W1,1

Bx,y ⇔ (Px,y+1 ∨ Px,y-1 ∨ Px+1,y ∨ Px-1,y)

Sx,y ⇔ (Wx,y+1 ∨ Wx,y-1 ∨ Wx+1,y ∨ Wx-1,y)

W1,1 ∨ W1,2 ∨ … ∨ W4,4

¬W1,1 ∨ ¬W1,2 // o Wumpus não pode estar em dois quadrados ao mesmo

¬W1,1 ∨ ¬W1,3

⇒ 64 símbolos distintos % 155 sentenças

função LP-Wumpus-Agent(percepções) retorna ação entradas: percepções, uma lista, [fedor, brisa, resplendor] variáveis estáticas : BC, base de conhecimento contendo a física do mundo de Wumpus

x,y,orientação, posição do agente (inic [1,1] e orient (direita)) visitado, uma matriz indicando que quadrados foram visitados, inicialmente falso ação, a ação mais recente do agente, inicialmente nula plano, uma seqüência de ações, inicialmente vazia

atualizar x, y orientação, visitado com base em ação se fedor então TELL(BC, Sx,y) senão TELL(BC, ¬Sx,y) se brisa então TELL(BC, Bx,y) senão TELL(BC, ¬Bx,y) se resplendor então ação $ agarrar senão se plano é não-vazio então ação $ DESEMPILHA(plano) senão se para algum quadrado de borda[i,j], ASK(BC,(¬PIJ ٧۷ ¬WIJ)) é V ou para algum quadrado de borda[i,j], ASK(BC,(Pij٧۷Wij)) é falsa então faça plano $ BUSCA-GRAFO-A*(PROB-ROTEAMENTO[x,y], orientação, [i,j],visitados)) ação $ DESEMPILHA(plano) senão ação $ um movimento escolhido aleatoriamente retornar ação

Inferência usando LP no mundo de Wumpus

! KB deve conter sentenças sobre a situação física de todas as posições.

! Para cada tempo t e cada posição [x,y],

Lx,y ∧ OlhandoDireitat ∧ PraFrentet ⇒ Lx+1,y ! Proliferação de cláusulas

Limitações da Lógica Proposicional

Sumário !  Agentes Lógicos realizam inferência em uma base de conhecimento

para derivar novas sentenças e tomar decisões. !  Conceitos básicos de lógica:

!  sintaxe: estrutura formal das sentenças declarativas

!  semântica: valor de verdade relativamente aos modelos !  Conclusão: verdade necessária de uma sentença dado outra !  inferência: derivação de sentenças a partir de outras sentenças

!  Consistência: derivações produzem apenas frases que são consequência lógica

!  completude/completeza: derivações conseguem produzir todas as frases que são consequências lógicas da KB

!  O mundo do Wumpus requer a capacidade de lidar com informação parcial e negativa, raciocínio por casos, etc.

!  Encadeamento para a frente e para trás têm complexidade temporal linear na dimensão da KB, são completos para cláusulas de Horn.

!  Resolução é completa para a lógica proposicional

Lógica de Primeira Ordem

Roteiro

! Porque LPO? ! Sintaxe e semântica ! Usando LPO ! O mundo de Wumpus em LPO ! Engenharia do Conhecimento em LPO

Pros e cons da lógica proposicional

☺ Lógica Propositional é declarativa ☺ Lógica Proposicional permite informação parcial/disjuntiva/negada

!  (contrariamente as bases de dados e estruturas de dados) ☺ Lógica Proposicional é composicional:

!  Significado de B1,1 ∧ P1,2 é derivado do significado de B1,1 e deP1,2

☺ Significado em LP é independente de contexto !  (Na linguagem natural o significado depende do contexto)

' A lógica proposicional tem poder de expressão muito limitado !  (contrariamente à linguagem natural) !  Ex.., Não se pode dizer “Poços ocasionam brisas em quadrados

adjacentes” sem ter que escrever uma setença pra cada quadrado.

Lógica de primeira ordem ! Enquanto a lógica proposicional assume que

o mundo contém apenas fatos, ! a lógica de primeira ordem (como a

linguagem natural) assume que o mundo contém: !  Objetos: pessoa, casa, números, cores, jogos,

guerras, … !  Relações: vermelho, redondo, primo, irmão de ,

maior do que, parte de , vem entre …. !  Funções: Pai de , melhor amigo , um mais que,

mais, …

Lógicas em geral

Sintaxe da LPO

! Constantes KingJohn, 2, NUS,... ! Predicados Brother, >,... ! Funções Sqrt, LeftLegOf,... ! Variáveis x, y, a, b,... ! Conectivos ¬, ⇒, ∧, ∨, ⇔

! Igualdade = ! Quantificadores ∀, ∃

Sentenças atômicas

Sentença atômica = predicado (termo1,...,termon) ou termo1 = termo2

Termo = função (termo1,...,termon)

ou constante ou variável !  Ex., Brother(KingJohn,RichardTheLionheart) !  >(Length(LeftLegOf(Richard)),

Length(LeftLegOf(KingJohn))) ( A perna esquerda de Richard é maior do que a de King John)

Sentenças complexas !  Sentenças complexas são feitas a partir de

sentenças atômicas usando conectivos ¬S, S1 ∧ S2, S1 ∨ S2, S1 ⇒ S2, S1 ⇔ S2,

Ex. Irmão(KingJohn,Richard) ⇒ Irmão(Richard,KingJohn)

>(1,2) ∨ ≤ (1,2) >(1,2) ∧ ¬ >(1,2)

Verdade em Lógica de 1a Ordem !  Setenças são verdadeiras em relação a um modelo e uma

interpretação. !  Modelos contêm objetos (elementos do domínio) e relações

entre eles !  Uma interpretação especifica referentes para:

Símbolos de constantes → objetos Símbolo de Predicados → relações Símbolos de funções → relações funcionais

!  Uma sentença atômica predicate(termo1,...,termon) é verdade sse os objetos referenciados por termo1,...,termon estão na relação referenciada por predicate

Modelos para a LPO: Exemplo

Como representar esse modelo em sentenças???

Modelos para a LPO: Exemplo Para alguns casos restritos, podemos tentar enumerar os modelos para um dado vocabulário de uma KB: Para cada número de elementos no domínio n de 1 até ∞ Para cada predicado k-ário Pk no vocabulário Para cada relação k-ária possível com n objetos Para cada símbolo de constante C no vocabulário

Para cada escolha de referente para C em n objetos A obtenção das conclusões lógicas por enumeração não vai ser nada fácil!

Quantificação Universal !  ∀<variáveis> <sentenças>

Todo mundo no CEFET é inteligente ∀x Em(x,CEFET) ⇒ Inteligente(x)

!  ∀x P é verdade em um modelo m sse P é verdade com x sendo

cada possível objeto no modelo

!  Grosso modo, equivale a uma conjunção de instanciações de P

Em(Petrônio,CEFET) ⇒ Inteligente(Petrônio) ∧ Em(Marcília, CEFET) ⇒ Inteligente(Marcília) ∧ Em(Assunção, CEFET) ⇒ Inteligente(Assunção) ∧ ...

Um erro comum a evitar

!  Normalmente, ⇒ é o principal conectivo com ∀

!  Erro comum: usar ∧ como o principal conectivo com ∀:

∀x Em(x,CEFET) ∧ Inteligente(x) significa: “Todo mundo está no CEFET e todo mundo é inteligente”

Quantificação Existencial !  ∃<variáveis> <sentenças>

!  Alguém no CEFET é inteligente:

!  ∃x Em(x,CEFET) ∧ Inteligente(x)

!  ∃x P é verdade em um modelo m sse P é verdade sendo x algum objeto possível no modelo

!  Grosso modo, equivale a uma disjunção de instanciações de P

Em(Petrônio, CEFET) ∧ Inteligente(Petrônio)

∨ Em(Marcília, CEFET) ∧ Inteligente(Marcília) ∨ Em(Assunção, CEFET) ∧ Inteligente(Assunção) ∨ ...

Outro erro comum a evitar ! Normalmente, ∧ é o principal conectivo com ∃

! Erro comum: usar ⇒ como o principal conectivo com ∃:

∃x Em(x,CEFET) ⇒ Inteligente(x)

é verdade se existe alguém que não está no CEFET.

Propriedades dos Quantificadores

!  ∀x ∀y é o mesmo que ∀y ∀x !  ∃x ∃y é o mesmo que ∃y ∃x !  ∃x ∀y não é o mesmo que ∀y ∃x !  ∃x ∀y Ama(x,y)

!  “Existe uma pessoa que ama todo mundo” !  ∀y ∃x Ama(x,y)

!  “Todo mundo é amado por pelo menos uma pessoa” !  Dualidade dos quantificadores: cada um pode ser expressado

usando o outro !  ∀x Gosta(x,IceCream) ¬∃x ¬Gosta(x,IceCream) (Τοdos gostam de sorvete) (não existe ninguém que não goste de sorvete) !  ∃x Gosta(x,Brócolis) ¬∀x ¬Gosta(x,Brócolis) (Alguém gosta de brócolis) (Não é o caso que ninguém goste de brócolis)

Igualdade !  termo1 = termo2 é verdade sob uma dada interpretação sse

termo1 and termo2 referem-se ao mesmo objeto

!  Ex., irmão a partir de Progenitor:

∀x,y Irmão(x,y) ⇔ [¬(x = y) ∧ ∃m Progenitor(m,x) ∧ Progenitor(m,y) ]

Alguns exemplos !  Irmãos são amigos

∀ x,y Irmão(x,y) "Amigo(x,y).

!  A Amizade é simétrica

!  ∀ x,y Amigo(x,y) ↔ Amigo(y,x).

!  A mãe de alguém é o seu progenitor feminino

!  ∀ x,y Mãe(x,y) ↔ (Feminino(x) ^ Progenitor(x,y)).

!  Um primo é um filho de um dos irmãos dos pais

!  ∀ x,y Primo(x,y) ↔ ∃ p,ps Progenitor(p,x) ^ Irmão(ps,p)^ Progenitor(ps,y)

Usando a LPO Domínio dos conjuntos: !  ∀s Conjunto(s) ⇔ (s = {} ) ∨ (∃x,s2 Conjunto(s2) ∧ s = {x|s2}) !  ¬∃x,s {x|s} = {} !  ∀x,s x ∈ s ⇔ s = {x|s} !  ∀x,s x ∈ s ⇔ [ ∃y,s2} (s = {y|s2} ∧ (x = y ∨ x ∈ s2))] !  ∀s1,s2 s1 ⊆ s2 ⇔ (∀x x ∈ s1 ⇒ x ∈ s2) !  ∀s1,s2 (s1 = s2) ⇔ (s1 ⊆ s2 ∧ s2 ⊆ s1) !  ∀x,s1,s2 x ∈ (s1 ∩ s2) ⇔ (x ∈ s1 ∧ x ∈ s2) !  ∀x,s1,s2 x ∈ (s1 ∪ s2) ⇔ (x ∈ s1 ∨ x ∈ s2)

Interagindo com KBs em LPO !  Suponhamos um agente no mundo de Wumpus usando uma KB em LPO que

percebe um cheiro e uma brisa mas não cintilação em t=5

Tell(KB,Percepção([Cheiro, Brisa,Nada],5)) Ask(KB,∃a MelhorAção(a,5))

!  I.e., a KB conclui a melhor ação particular para t=5? Resposta: Sim, {a/Atirar} ← substituição (binding list)

!  Dada uma sentença S e uma substituição σ !  Given a sentence S and a substitution σ, !  Sσ denota o resultado da substituição de σ em S. Ex.

S = MaisInteligente(x,y) σ = {x/Marcília,y/Petrônio} Sσ = MaisInteligente(Marcília,Petrônio)

!  Ask(KB,S) retorna algum ou todas σ tais que KB╞ Sσ

Base de Conhecimento para o Mundo Wumpus

! Percepção !  ∀t,s,b Percebe([s,b,Cintilação],t) ⇒ Cintilação(t)

! Reflexo ! ∀t Cintilação(t) ⇒ MelhorAção(Segurar,t)

! Reflexo com estado interno !  ∀t EmOuro(t) ^ ~Segurando(Ouro,t) " MelhorAção(Segurar,t)

Deduzindo propriedades Ocultas !  ∀x,y,a,b Adjacente([x,y],[a,b]) ⇔

[a,b] ∈ {[x+1,y], [x-1,y],[x,y+1],[x,y-1]}

Propriedades dos Quadrados: !  ∀s,t At(Agente,s,t) ∧ Brisa(t) ⇒ Brisa(s)

Quadrados próximos a poços possuem brisa:

!  Regra de Diagnóstico --- infere causa a partir de efeito ∀s Brisa(s) ⇒ ∃{r} Adjacente(r,s) ∧ Poço(r)

!  Regra Causal --- infere efeito a partir da causa ∀r Poço(r) ⇒ [∀s Adjacente(r,s) ⇒ Brisa(s) ]

Engenharia do conhecimento 1.  Identifique a tarefa 2.  Reuna o conhecimento relevante 3.  Decida sobre o vocabulário dos predicados

funções e constantes 4.  Codifique o conhecimento geral sobre o

domínio 5.  Codifique a descrição de uma instância

específica do problema 6.  Coloque algumas questões para a máquina

de inferência e pegue as respostas 7.  Debug a base de conhecimento

Domínio dos circuitos eletrônicos

Somador de 1 bit

1.  Identifique a tarefa !  O circuito soma corretamente? (verificação do circuito)

2.  Reunir o conhecimento relevante !  Composto de fios e portas; Tipos de portas(AND, OR,

XOR, NOT) !  Irrelevante: tamanho, desenho, cor e custo das portas

3.  Definir o vocabulário

!  Alternativas:

Type(X1) = XOR Type(X1, XOR) XOR(X1)

Domínio dos circuitos eletrônicos 1.  Codificar o conhecimento geral do problema

!  ∀t1,t2 Connectados(t1, t2) ⇒ Sinal(t1) = Sinal(t2) !  ∀t Sinal(t) = 1 ∨ Sinal(t) = 0

!  1 ≠ 0

!  ∀t1,t2 Conectados(t1, t2) ⇒ Conectados(t2, t1)

!  ∀g Tipo(g) = OR ⇒ Sinal(Saida(1,g)) = 1 ⇔ ∃n Sinal(Entrada(n,g)) = 1

!  ∀g Tipo(g) = AND ⇒ Sinal(Saida(1,g)) = 0 ⇔ ∃n Sinal(Entrada(n,g)) = 0

!  ∀g Tipo(g) = XOR ⇒ Sinal(Saida(1,g)) = 1 ⇔ Sinal(Entrada(1,g)) ≠ Sinal(Entrada(2,g))

!  ∀g Tipo(g) = NOT ⇒ Sinal(Saida(1,g)) ≠ Sinal(Entrada(1,g))

1.  Codificar uma instância específica do problema

Tipo(X1) = XOR Tipo(X2) = XOR

Tipo(A1) = AND Tipo(A2) = AND

Tipo(O1) = OR

Conectados(Saída(1,X1),Entrada(1,X2)) Conectados(Entrada(1,C1), Entrada(1,X1))

Conectados(Saída(1,X1), Entrada(2,A2)) Conectados(Entrada(1,C1), Entrada(1,A1))

Conectados(Saída(1,A2), Entrada(1,O1)) Conectados(Entrada(2,C1), Entrada(2,X1))

Conectados(Saída(1,A1), Entrada(2,O1)) Conectados(Entrada(2,C1), Entrada(2,A1))

Conectados(Saída(1,X2),Saída(1,C1)) Conectados(Entrada(3,C1), Entrada(2,X2))

Conectados(Saída(1,O1),Saída(2,C1)) Conectados(Entrada(3,C1),Entrada(1,A2))

1.  Coloque questões para o procedimento de inferência

Quais são os possíveis conjuntos de valores para todos os terminais no circuito somador?

∃i1,i2,i3,o1,o2 Sinal(Entrada(1,C1)) = i1 ∧ Sinal(Entrada(2,C1)) = i2 ∧ Sinal(Entrada(3,C1)) = i3 ∧ Sinal(Saída(1,C1)) = o1 ∧ Sinal(Saída(2,C1)) = o2

1.  Debug a base de conhecimento Poderíamos ter omitido assertivas como 1 ≠ 0

Sumário

! Lógica de Primeira Ordem !  Objetos e relação são primitivos semânticos

! syntaxe: constantes, funções, predicados, igualdade, quantificadores

! Aumenta o poder de expressão: suficiente para definir o mundo wumpus

Inferência em LPO

Chapter 9

Roteiro ! Reduzindo inferência em LPO para

inferência em LP ! Unificação ! Modus Ponens Generalizado ! Encadeamento Pra Frente ! Encadeamento pra Trás ! Resolução

Instanciação Universal (UI) !  Toda instância de uma senteça universalmente quantificada é

consequência lógica da mesma. ∀v α

Subst({v/g}, α) Para toda variável v e termo básico g

!  Ex., ∀x Rei(x) ∧ Guloso(x) ⇒ Mau(x) leva a:

Rei(John) ∧ Guloso(John) ⇒ Mau(John) Rei(Richard) ∧ Guloso(Richard) ⇒ Mau(Richard) Rei(Pai(John)) ∧ Guloso(Pai(John)) ⇒ Mau(Pai(John)) .

Instanciação Existencial !  Para toda senteça α, variável v e símbolo de

constante k que não apareça em outro lugar na based de conhecimento:

∃v α

Subst({v/k}, α)

!  Ex., ∃x Coroa(x) ∧ NaCabeça(x,John) leva a:

Coroa(C1) ∧ NaCabeça(C1,John)

C1 is uma nova constante chamada constante de Skolem

Redução à inferência Proposicional Suponha que a KB contenha o seguinte:

∀x Rei(x) ∧ Guloso(x) ⇒ Mau(x) Rei(John) Guloso(John) Irmao(Richard,John)

!  Instanciando a setença universal em todas as formas possíveis

teremos:

Rei(John) ∧ Guloso(John) ⇒ Mau(John) Rei(Richard) ∧ Guloso(Richard) ⇒ Mau(Richard) Rei(John) Guloso(John) Irmao(Richard,John)

!  A nova base de conhecimento “proposicionalizada” será:

Rei(John), Guloso(John), Mau(John), etc.

Redução cont. !  Toda KB em LPO pode ser “proposicionalizada” de

forma a preservar a conseqüência lógica.

!  (Uma sentença básica (ground) é conseqüência lógica da nova KB sse ela é conseqüência da KB original)

!  Idéia: “proposicionalizar” a KB e aplicar as perguntas, aplicar a resolução e retornar os resultados

!  Problema: com funções existem infinitos termos básicos. !  Ex., Father(Father(Father(John)))

Redução cont. Teorema de Herbrand (1930). Se uma setença α é conseqüência

de uma KB em LPO, ela é conseqüência de um subconjunto finito da KB proposicionalizada.

Idéia: For n = 0 to ∞ do

Criar uma KB proposicional instanciando com profundidade de “n” termos

verificar se α is conseqüência desta KB Problema: Funciona se α is conseqüência, fica em loop se α não é

conseqüência Teorema de Turing (1936), Church (1936) Conseqüência lógica

para a LPO é semidecidível (Existem algoritmos que dizem sim para toda sentença dedutível, mas nenhum algoritmo existe que diga não para toda sentença não dedutível)

Problemas com proposicionalização

!  Geração de sentenças irrelevantes !  Ex. A partir de :

∀x Rei(x) ∧ Guloso(x) ⇒ Mau(x) Rei(John) ∀y Guloso(y) Irmao(Richard,John)

!  É óbvio que Mau(john), mas proposicionalização produz fatos como

Guloso(Ricardo) que são irrelevantes

!  Com p predicados de aridade k e n constants, teremos p·nk

instâncias.

Unificação !  Podemos obter uma inferência imediata se podemos encontrar uma

substituição θ tal que Rei(x) e Guloso(x) casa com Rei(John) e Guloso(y)

θ = {x/John,y/John} funciona

!  Unifica(α,β) = θ if αθ = βθ p q θ Conhece(John,x) Conhece(John,Jane) {x/jane} Conhece(John,x) Conhece(y,Bill) {x/Bill, y/John} Conhece(John,x) Conhece(y,Mae(y)) {y/John,x/Mae(John)} Conhece(John,x) Conhece(x,OJ) = falha

!  Padronização separada elimina sobreposição de variáveis, e.g., Conhece(z17,Bill)

Unificação ! Para unificar Conhece(John,x) e Conhece(y,z),

θ = {y/John, x/z } or θ = {y/John, x/John, z/John}

! O primeiro unificador é mais geral que o segundo.

! Existe um único Unificador Mais Geral (UMG) que é exclusivo para renomear variáveis. UMG = { y/John, x/z }

O algoritmo de unificação

Modus Ponens Generalizado(GMP)

p1', p2', … , pn', ( p1 ∧ p2 ∧ … ∧ pn ⇒q) qθ p1' é Rei(John) p1 é Rei(x)

p2' é Guloso(y) p2 é Guloso(x)

θ é {x/John,y/John} q é Mau(x)

q θ é Mau(John)

!  GMP é utilizado com KB de cláusulas definidas (exatamente um

literal positivo) !  Todas as variáveis são universalmente quantificadas

where pi'θ = pi θ for all i

Exemplo de base de conhecimento

!  A lei americana estabelece que é crime um americano vender armas para nações hostis. O país Nono, um inimigo dos EUA, tem alguns mísseis, e todos estes mísseis foram vendidos pelo coronel West, que é americano.

!  Prove que o coronel West é um criminoso.

Exemplo de base de conhecimento. Cont.

... é um crime para um americano vender armar a nações hostis: Americano(x) ∧ Arma(y) ∧ Vendeu(x,y,z) ∧ Hostil(z) ⇒ Criminoso(x)

Nono … tem alguns mísseis, i.e., ∃x Possui(Nono,x) ∧ Missil(x): Possui(Nono,M1) ^ Missil(M1)

… todos os mísseis foram vendidos pelo coronel West Missil(x) ∧ Possui(Nono,x) ⇒ Vendeu(West,x,Nono)

Misseis são armas: Missil(x) ⇒ Arma(x)

Um inimigo dos EUA é "hostil“: Inimigo(x,EUA) ⇒ Hostil(x)

West, que é um americano … Americano(West)

O país Nono, um inimigo da America … Inimigo(Nono,EUA)

Algoritmo de encadeamento pra frente

Prova de encadeamento pra frente

Propriedades do EF !  Consistente e completo para LPO com cláusulas

definidas

!  Datalog = Cláusulas definidas em LPO + nenhuma função

!  EF conclui um Datalog em um número finito de iterações

!  Em geral não termina se α não é conseqüência lógica

!  Isto é inevitável : conseqüência lógica com cláusulas definidas é semidecidível

Eficiência do EF

EF Incremental: não há necessidade de “casar” uma regra na iteração k se uma premissa não foi adicionada na iteração k-1 ⇒ Casa-se cada regra cuja premissa contém um literal positivo recentemente adicionado.

Casamento próprio pode ser expressivo: Indexação de bases de dados permite O(1)

recuperação de fatos conhecidos !  e.x., a questão Missil(x) retorna Missil(M1)

EF é amplamente utilizada em bancos de dados dedutivos.

Exemplo de casamento difícil

! Coloravel() é inferido sse o PSR tem uma solução

! O casamento é NP-Difícil

Dif(wa,nt) ∧ Dif(wa,sa) ∧ Dif(nt,q) ∧ Dif(nt,sa) ∧ Dif(q,nsw) ∧ Dif(q,sa) ∧ Dif(nsw,v) ∧ Dif(nsw,sa) ∧ Dif(v,sa) ⇒ Coloravel() Dif(Red,Blue) Dif (Red,Green) Dif(Green,Red) Dif(Green,Blue) Dif(Blue,Red) Dif(Blue,Green)

Algoritmo com encadeamento pra trás

SUBST(COMPOSE(θ1, θ2), p) = SUBST(θ2, SUBST(θ1, p))

Exemplo de ET

Propriedade do ET ! Busca recursiva em profundidade: espaço

linear no tamanho da prova !  Incompleta (loops infinitos)

! ⇒ corrige-se checando a meta atual em relação com todas as metas na pilha

!  Ineficiente devido a sub metas repetidas ! ⇒ Corrige-se colocando os resultados prévios em

uma cache (espaço extra) ! Muito usada em programação lógica

Programação Lógica: Prolog !  Algoritmo = Lógica + Controle !  Base: backward chaining (ET) com cláusulas de Horn

Muito usado na Europe e no japão (base do project 5ª geração)

!  Programa = conjunto de cláusulas = head (cabeça) :- literal1, … literaln. Criminoso(X) :- americano(X), arma(Y), vendeu(X,Y,Z), hostil(Z).

!  Busca em profundidade ET esquerda pra direita !  Predicados pre-prontos para aritmética:, ex, X is Y*Z+3 !  Predicados pré-prontos possuem efeitos colaterais (ex. Entradas e saidas) !  Predicados do tipo assert/retract !  Pressuposto de um mundo fechado (negação como falha)

!  ex., dada alive(X) :- not dead(X). !  alive(joe) obtém sucesso se dead(joe) falha

Prolog

!  Acrescentando uma lista à outra append([],Y,Y).

append([X|L],Y,[X|Z]) :- append(L,Y,Z).

!  Pergunta (meta): append(A,B,[1,2]) ? !  resposta: A=[] B=[1,2] A=[1] B=[2]

A=[1,2] B=[]

Resolução: breve sumário !  Versão em primeira ordem

l1 ∨ ··· ∨ lk, m1 ∨ ··· ∨ mn (l1 ∨ ··· ∨ li-1 ∨ li+1 ∨ ··· ∨ lk ∨ m1 ∨ ··· ∨ mj-1 ∨ mj+1 ∨ ··· ∨ mn)θ

onde Unificar (li, ¬mj) = θ.

!  Considera-se que as duas cláusulas foram padronizadas em separado

de forma que elas não compartilham variáveis

!  Por exemplo, ¬Rico(x) ∨ Infeliz(x)

Rico(Ken) Unhappy(Ken)

with θ = {x/Ken} !  Aplicar passos de resolução a FNC(KB ∧ ¬α); completo para LPO

Conversão para FNC !  Todo mundo que ama todos os animais é amado por

alguém: ∀x [∀y Animal(y) ⇒ Loves(x,y)] ⇒ [∃y Loves(y,x)]

!  1.Elimina-se bicondicionais e implicações ∀x [¬∀y ¬Animal(y) ∨ Loves(x,y)] ∨ [∃y Loves(y,x)]

!  2. Mover ¬ pra dentro: ¬∀x p ≡ ∃x ¬p, ¬ ∃x p ≡ ∀x ¬p ∀x [∃y ¬(¬Animal(y) ∨ Loves(x,y))] ∨ [∃y Loves(y,x)] ∀x [∃y ¬¬Animal(y) ∧ ¬Loves(x,y)] ∨ [∃y Loves(y,x)] ∀x [∃y Animal(y) ∧ ¬Loves(x,y)] ∨ [∃y Loves(y,x)]

Conversão para FNC cont. 1.  Padronização de variáveis : cada quantificador usa uma

diferente ∀x [∃y Animal(y) ∧ ¬Loves(x,y)] ∨ [∃z Loves(z,x)]

2.  Skolemizar: uma forma mais geral de instanciação

existencial. Cada variável existential é substituída por uma função de Skolem of

das variáveis quantificadas universalmente. ∀x [Animal(F(x)) ∧ ¬Loves(x,F(x))] ∨ Loves(G(x),x)

3.  Desprezar quantificadores Universais:

[Animal(F(x)) ∧ ¬Loves(x,F(x))] ∨ Loves(G(x),x)

4.  Distribuir ∨ sobre ∧ : [Animal(F(x)) ∨ Loves(G(x),x)] ∧ [¬Loves(x,F(x)) ∨ Loves(G(x),x)]

Prova por resolução de cláusulas definidas

curso inteligência artificial - parte 2 -

Education

inteligência artificial i representação do conhecimento ...

inteligência artificial - computação...

o que é inteligência artificial? inteligência artificial

curso inteligência artificial - parte 1 -

inteligência artificial: equidade, justiça e...

curso de inteligência artificial - parte 3 -

inteligÊncia artificial introdução. o que é...

inteligência artificial análise e desenvolvimento de...

inteligência artificial i aprendizagem (parte ii -...

inteligência artificial análise e desenvolvimento de...

inteligência artificial - universidade da...

automação, controle e inteligência artificial parte i:...

inteligência artificial i - universidade federal de campina...

tópicos especiais: inteligência artificial ricardo...

inteligência artificial na educação -...

inteligÊncia biolÓgica versus inteligÊncia artificial

inteligência artificial na educação...parte 1 parte 2...

introdução à inteligência artificialintrodução à...

inteligência artificial