Mały poradnik do biblioteki PyKE

pyke - notatka 1

* Definiowanie faktów (składnia):

nazwa_relacji(argument, argument, .....)

parents_of(Bruce, Thomas, Anna)
parents_of($child, $father, $mother)

father_of(Bruce, Thomas)
mother_of(Bruce, Anna)

* Dopasowywanie wzorców:
- ze zmiennymi
fakt: parents_of(Bruce, Thomas, Anna)
wzorzec dopasowania: parents_of($child, $father, $mother)
rezultat:
	$child = Bruce
	$father = Thomas
	$mother = Anna

- z elementami stałymi
wzorzec: parents_of($child, Thomas, $mother)
rezultat:
	$child = Bruce
	$mother = Anna

wzorzec: parents_of($child, Thomas, $_mother)
rezultat:
	$child = Bruce

- z zestawami
wzorzec: parents_of($child, $father, *$rest)
rezultat:
	$child = Bruce
	$father = Thomas
	$rest = (Anna,)

- UWAGA

wzorzec: parents_of($name, $name, $_mother)
będzie wyszukiwał faktów, gdzie syn i ojciec mają takie samo
imię
fakt: parents_of(Jan, Jan, Anna) - będzie pasować


* Reguły
- zwykłe (działające do przodu)

foreach
	wzorzec_A (ORAZ)
	wzorzec_B (ORAZ)
	wzorzec_C
assert
	fakty

zmienne występujące we wzorcach można później wykorzystać
do budowania faktów - to jest główny cel

- wsteczne

use
	fakt lub wzorzec	(tylko jeden!)
when
	wzorzec_A (ORAZ)
	wzorzec_B itd.

* Bazy
- faktów: może być budowana w trakcie działania programu
	lub wczytana z pliku *.kfb
	składnia identyczna jak składnia faktów (bez zmiennych!)
- reguł: wczytywana z pliku *.krb
	składnia: opisana w Regułach, każda reguła ma swoją nazwę:
	
	legal_knapsack			- nazwa
		use legal_knapsack($Pantry, $Capacity, $Knapsack)
		when
			subseq($Knapsack, $Pantry)
			check sum(map(lambda x: x[1], $Knapsack)) <= $Capacity


	ojcowie			- przykład rozbicia faktu na drobne
		foreach
			parent_of($child, $father, $mother)
		asser
			father_of($child, $father)
			mother_of($child, $mother)
	
	
- pytań: wczytywana z pliku *.kqb
	składnia:
	
	nazwa_pytania(parametry, $odp)
		Tekst pytania - może zawierać parametry
		---
		$odp = wzorzec odpowiedzi

	PRZYKŁAD:
	
	zjedzono($posilek, $odp)
		Zjadłeś $posilek?
		---
		$odp = yn
	
	^ odpowiedź jest typu bool (prawa/fałsz, yes/no)
	
	Pytań używa się w regułach w miejscu wzorca, np.
	
	sprawdz_glodny
		use
			najedzony()
		when
			zjedzono(obiad, True)

	^ w momencie natrafienia na tę regułę zostanie zadane
	pytanie (odp zostanie zapamiętaba "na zawsze")

* Użycie z poziomu Pythona:

import pyke		# import biblioteki
baza_wiedzy = pyke.knowledge_engine.engine(__file__)
baza_wiedzy.activate('nazwa_pliku_bez_rozszerzenia')
# dodawanie faktów "w locie":
#baza_wiedzy.assert_('podbaza', 'nazwa_faktu', ('parametr', ..... ))
baza_wiedzy.assert_('family', 'parents_of', ('Jan', "Michał", "Maria" ))
# dowodzenie
baza_wiedzy.prove_1_goal('family.father_of(Jan, Michał)')

pyke - notatka 2

* Fakty - definiowane w plikach *.kfb lub
    podczas działania programu (!)
składnia:

nazwa_relacji(argumenty, .......)

na tej podstawie budujemy bazę faktów

* Dopasowania wzorców
    wzorce są używane przy tworzeniu reguł
- napisowe
fakt:  parents_of(Adam, Jakub, Olga)
wzorzec: parents_of(Adam, Jakub, Olga)
    pasuje tylko do tego jednego faktu
    
- ze zmiennymi
fakt:  parents_of(Adam, Jakub, Olga)
wzorzec: parents_of($child, $father, $mother)

zmienna zapisywana jest w postaci: $nazwa
rezultat:
    $child = Adam
    $father = Jakub
    $mother = Olga

można mieszać z wzorcami napisowymi:
wzorzec:  parents_of($child, Jakub, $mother)
pasuje do wszystkich dzieci Jakuba

można używać zmiennych anonimowych:
fakt:  parents_of(Adam, Jakub, Olga)
wzorzec:  parents_of($child, Jakub, $_mother)
rezultat:
    $child = Adam

zmienne, których nazwa zaczyna się od podkreślnika
są anonimowe i nie są w żaden sposób uwzględnianie
w dopasowaniach

- z zestawami

fakt:  parents_of(Adam, Jakub, Olga)
wzorzec:  parents_of($child, Jakub, *$other)
rezultat:
    $child = Adam
    $other = (Olga,)

fakt: parents_of(Adam, Jakub, Olga, Anna, Zuzanna)
rezultat:
    $child = Adam
    $other = (Olga, Anna, Zuzanna)

fakt: parents_of(Adam, Jakub)
rezultat:
    $child = Adam
    $other = ()

* uwaga
w danym wzorcu zmienna jest przypisywana przy pierwszym
dopasowaniu, a następnie traktowana jest już jako napis
o treści jak w tym pierwszym dopasowaniu

wzorzec: parents_of($name, $name, $_)
będzie pasował do każdego faktu, gdzie imię dziecka
jest takie samo jak imię rodzica, np:
parents_of(Adam, Adam, Ewa)

na tej podstawie możemy budować Reguły

* Reguły - definiowane tylko w plikach *.krb

a) zwykłe (działają do przodu)

składnia:

nazwa
    foreach
        wzorzec_1 (ORAZ)
        wzorzec_2
        itd.
    assert
        fakt_1
        fakt_2
        itd.

b) wsteczne (działa do tyłu)

składnia:

nazwa
    use
        fakt lub wzorzec (wyłącznie jeden!)
    when
        wzorzec  (ORAZ)
        wzorzec_2
        itd.

* Pytania - definiowane tylko w plikach *.kqb
mogą zastępować fakty/wzorce podczas definiowania reguł
w takim przypadku użytkownik będzie musiał odpowiedzieć
na zadane pytanie i jego odpowiedź zostanie zapamiętana

składnia:

nazwa_pytania(parametry, $odp)
    Tekst pytania z możliwością użycia parametrów
    ---
    $odp = definicja schematu/typu odpowiedzi
    
przykład definicji pytania:

zjedzono($posilek, $odp)
    Czy pacjent zjadł $posilek?
    ---
    $odp = yn

przykład użycia pytania w regule:

czy_glodny
    use
        pacjent_najedzony()
    when
        zjedzono(obiad, True)

działanie: chcąc sprawdzić, czy pacjent_najedzony
uruchamiamy pytanie czy zjedzono obiad z oczekiwaną
odpowiedzią "tak" (True)
innymi słowy: jeśli pacjent zjadł obiad, to jest najedzony

pyke - notatka 3

http://pyke.sourceforge.net/

* Fakty

relacja(argument1, argument2, itd.)
np.:

rodzice(Adam, Jakub, Olga)
rodzice(Jan, Michał, Anna)
jest_zimno()

* dopasowanie wzorców
rodzice(Adam, Jakub, Olga)      - pasuje do jednego faktu
- ze zmiennymi:

rodzice($dziecko, $ojciec, $matka)

notacja zmiennych jest następująca:
$nazwa_zmiennej

zmienna jest ustawiana przy pierwszym przyrównaniu
i występuje jako napis w dalszej części reguły (poniżej)

- z zestawiami:

fakt: zwierzaki(Ala, kot, pies, chomik)
wzorzec: zwierzaki($osoba, *$zwierzaki)
rezultat:
$osoba = Ala
$zwierzaki = (kot, pies, chomik)

fakt: zwierzaki(Tomek)
wzorzec: j.w.
rezultat:
$osoba = Tomek
$zwierzaki = ()

- ignorowane zmienne
zapis $_nazwa - nazwa nie jest wymagana

np.

fakt: zwierzaki(Ala, kot, pies)
wzorzec: zwierzaki($_osoba, *$zwierzaki)
rezultat:
$zwierzaki = (kot, pies)

* Reguły
- zwykłe (działające w przód)

nazwa_reguły
    foreach
        wzorzec1 (ORAZ)
        wzorzec2 (ORAZ)
        kolejny...
    assert
        fakt1    (tworzenie nowych faktów)
        fakt2 itd.

przykład:

rodzice
    foreach
        rodzice($dziecko, $ojciec, $matka)
    assert
        ojciec($dziecko, $ojciec)
        matka($dziecko, $matka)


- wsteczne

nazwa_reguły
    use
        fakt    (tylko jeden!)
    when
        wzorzec1    (ORAZ)
        wzorzec2 itd.

* Pytania
- pytania można wykorzystywać w miejscach wzorców
- odpowiedź na dane pytanie jest zapamiętywana
(tzn. jeśli będzie trzeba ponownie zadać to samo pytanie,
to zostanie użyta już udzielona odpowiedź)

składnia:

nazwa_pytania(parametry, $odp)      - $odp - oczekiwana odpowiedź
    tekst pytania - może zawierać parametry
    ---
    $odp = wzorzec odpowiedzi

np.    
zjedzono($posilek, $odp)
    Czy pacjent zjadł $posilek?
    ---
    $odp = yn

użycie w regule:

sprawdzenie_glodu
    use
        pacjent_najedzony()
    when
        zjedzono(obiad, True)

* Bazy
- faktów: pliki *.kfb lub tworzenie faktów "w locie" podczas działania programu
- reguł: pliki *.krb
- pytań: pliki *.kqb


######
#Użycie z poziomu Pythona 3;
##########################
from pyke import knowledge_engine     # import modułu
bazaw = knowledge_engine.engine(__file__)
bazaw.activate('moje_reguly')    # wczytanie bazy z pliku
# tworzenie faktów "w locie"
baza_wiedzy.assert_('rodzina', 'rodzice', ("Jan", "Michał", "Maria" ))
#baza_wiedzy.assert_(nazwa_bazy, relacja, parametry)

#dowodzenie zależności

bazaw.prove_1_goal('rodzina.ojciec(Jan, Michał)')

zadania domowe:

1. Stworzyć system pomagający przewieźć wilka, kozę i kapustę na drugą stronę rzeki
2. Spolszczyć przykład z relacjami rodzinnymi
3. Wybrać sobie jakiś system ekspertowy do zrealizowania (podać specyfikację na zajęciach)
4. (nadobow) Stworzyć system analizujący zagadkę Einsteina (musi móc odpowiedzieć na dowolne pytanie dot. osób w zagadce)