[[pl:prolog:prolog_lab:prolog_lab_metaprog]]
Pokaż stronę
Ostatnie zmianyIndeks

AIwiki

Dla Studentów

Zima / Winter 2021:

Old specialized AI courses

SMaDA/SMaIDA/AIDA

1. semester:

2. semester:

Informatyka (EAIiIB)

1. rok:

2. i 3. rok:

4. rok:

Studia Dr

Inne materialy dydaktyczne

Archiwum

Dyplomanci

Geist Season of Code

HeKatE

Public

Prolog Lab

Część główna

  1. Wprowadzenie
  2. Podstawy programowania
  3. Praca z listami (cz. 1)
  4. Praca z listami (cz. 2)
  5. Reprezentacja wiedzy

Część fakultatywna

Różnice

Różnice między wybraną wersją a wersją aktualną.

Odnośnik do tego porównania

Both sides previous revision Poprzednia wersja
Nowa wersja 		Poprzednia wersja
pl:prolog:prolog_lab:prolog_lab_metaprog [2010/01/06 08:24]
ikaf 		pl:prolog:prolog_lab:prolog_lab_metaprog [2019/06/27 15:50] (aktualna)
Linia 2: Linia 2:
 ====== - LAB: Metaprogramowanie w Prologu ====== ====== - LAB: Metaprogramowanie w Prologu ======
  
-===== - #5 WPROWADZENIE ===== +===== - Temat: Sprawdzanie typów termów ​=====
- +
-==== - Temat: Sprawdzanie typów termów ====+
  
 Prolog dostarcza szeregu predykatów,​ pozwalających na analizowanie typów termów. Prolog dostarcza szeregu predykatów,​ pozwalających na analizowanie typów termów.
Linia 13: Linia 11:
  
 <code prolog> <code prolog>
-var(X) +var(X). 
-nonvar(X)+nonvar(X).
 </​code>​ </​code>​
  
Linia 32: Linia 30:
 liczbą zmiennoprzecinkową ​ liczbą zmiennoprzecinkową ​
  
-==== - Temat: Konstruowanie i dekompzycja termów ==== +** Ćwiczenie:**
- +
- +
-Z racji tego, iż termy sa podstawową metodą strukturalizacji danych w Prolog, istnieje kilka mechanizmów wspomagających ich przetwarzanie:​ +
- +
-  =.. +
-operator pozwala na dynamiczną zamianę termu na listę i vice versa  +
-  functor(T,​N,​A) +
-predykat jest prawdziwy, jeżeli N pokrywa się z nazwą termu T o wartości A  +
-  arg(N,​T,​A) +
-predykat jest prawdziwy, jeżeli A jest Ntym argumentem termu T  +
- +
- +
-==== - Temat: Definiowanie operatorów ==== +
- +
- +
-W prologu bardzo łatwo można definiować własne operatory, co ułatwia przetwarzanie danych. +
- +
-Realizowane jest to przez predykat :- op(P, T, N), który definiuje N, jako operator typu T, o priorytecie P. +
- +
-Zdefiniowane w standardzie ISO operatory to: +
- +
-<​code>​ +
-1200 xfx -->,​ :- +
-1200 fx :-, ?- +
-1150 fx dynamic,​ discontiguous,​ initialization,​ module_transparent,​ multifile, thread_local,​ volatile +
-1100 xfy ;, | +
-1050 xfy ->,​ op*-> +
-1000 xfy ,​ +
-954 xfy \ +
-900 fy \+ +
-900 fx ~ +
-700 xfx <,​ =, =.., =@=, =:=, =<, ==, =\=, >, >=, @<, @=<, @>, @>=, \=, \==, is +
-600 xfy : +
-500 yfx +, -, /\, \/, xor +
-500 fx +, -, ?, \ +
-400 yfx *, /, //, rdiv, <<, >>, mod, rem +
-200 xfx ** +
-200 xfy ^ +
-</​code>​ +
- +
-Wszystkie mogą być zredefiniowane!. +
- +
-Gdyby nie operatory, to prosty program w Prologu: +
- +
-<code prolog>​ +
-go :- write('​Hello '), write('​World\n'​). +
-:- go. +
-</​code>​ +
- +
-Musialby wyglądać następująco (wszytko w notacji prefiksowej,​ zapisane jako termy): +
- +
-<code prolog>​ +
-:​-(go,','​(write('​Hello '​),​write('​World\n'​))). +
-:-(go). +
-</​code>​ +
- +
-Uwaga: obydwa programy są równoważne. W drugim programie widać, że klauzule złożone również zapisane są jako termy. +
- +
-Patrz również:​ +
-  ​* [[http://​gollem.science.uva.nl/​SWI-Prolog/​Manual/​operators.html|podręcznik SWI]] +
-  ​* [[http://​cs.union.edu/​~striegnk/​learn-prolog-now/​html/​node84.html#​subsec.l9.operators.def|Lean Prolog Now]] +
- +
-==== - Temat: Konstruowanie klauzul i Metainterpretery ==== +
- +
- +
-W Prologu występują dwa silne mechnizmy wspomagające metainterpretację kodu: +
- +
-  call(X) +
-wywołuje X, jako cel Prologu,  +
-  clause(Head,​Body) +
-odszukuje klauzulę o nagłówku Head, gdzie Body jest unifikowane z ciałem klauzuli; w przypadku faktów Body=true.  +
- +
-Meta programowanie to tworzenie programów, które przetwarzają kod innych programów. Przykłady metaprogramowania znaleźć można w np.: kompilatorach,​ analizatorach kodu, generatorach kodu. W Prologu metaprogramowanie jest naturalną techniką, dzięki czemu pisanie programów działających w diametralnie różnych paradygmatach jest proste. +
- +
- +
- +
- +
-==== - Temat: Systemy ekspertowe ==== +
- +
-W Prologu niezwykle prosto tworzy się systemy ekspertowe. +
- +
-W systemie ekspertowym można wyróżnić następujące elementy: +
- +
-  * baza wiedzy, czasami dzielona na: właściwą bazę wiedzy (czyli tą którą system dysponuje stale, od początku/​uruchomienia) i bazę faktów, które system odkrywa, dostaje, wypracowuje,​  +
-  * mechanizm wnioskujący,​ który przeprowadza właściwy proces wnioskowania,​ tj. odnajduje rozwiązanie/​odpowiedź  +
-  * mechanizm wyjaśniający,​ dlaczego jest to odpowiedź poprawna/​dopuszczalna,​  +
-  * interfejs użytkownika,​ pozwalający na komunikację z systemem.  +
- +
-Rysunek 1: Struktura Systemu Ekspertowego. +
- +
-{{expert-systems-arch.png}} +
- +
-Poniżej podane są przykłady różnych systemów. +
- +
- +
-=== - System: CAR === +
- +
-Źródło: Michael A. Covington, Donald Nute and André Vellino, //Prolog programming in depth//, Prentice-Hall,​ 1996. +
- +
-Cechy: +
-    * klauzule Prologu jako reprezentacja wiedzy +
-    * wbudowany mechanizm Prologu +
-    * wnioskowanie wstecz (abdukcja) ((Backward chaining inference, goal driven inference - stosowane w systemach diagnostycznych,​ w którym mamy ograniczoną (niewielką) liczbę możliwych hipotez, system stara się dowieść każdej z nich po kolei, zbierając informacje "po drodze"​)) +
-    * trywialny :-) +
-System: {{car.pl}} +
-Dodatkowo korzysta on z pliku {{getyesno.pl}} +
- +
-Przetestować działanie systemu.  +
-System diagnozuje przyczyną awarii samochodu. +
- +
-W przypadku tego systemu elementy systemu ekspertowego są odwzorowane przez: +
- +
-  * predykat //​defect_may_be/​1//​ -> baza wiedzy +
-  * predykat //​try_all_possibilities/​0//​ oraz mechanizm wnioskujący Prologu -> mechanizm wnioskujący +
-  * predykat //​explain/​1//​ -> mechanizm wyjaśniania +
-  * predykaty //​ask_question/​1//​ i //​user_says/​2//​ -> interfejs użytkownika +
- +
-=== - System: OOPS === +
-Źródło: Dennis Merritt, //Building Expert Systems in Prolog//, Springer-Verlag,​ 1989. +
- +
-Cechy: +
-    * własna reprezentacja reguł +
-    * kodowanie reguł na termach Prologu +
-    * własny mechanizm wnioskujący +
-    * wnioskowanie wprzód ((Forward chaining inference, data driven inference - stosowane w celu uniknięcia eksplozji kombinatorycznej,​ gdy możliwe jest (nieskończenie) wiele poprawnych odpowiedzi, system na podstawie danych "​odpala"​ odpowiednie reguły)) +
-    * wymienne bazy wiedzy +
- +
-Mechanizm wnioskujący:​ {{oops.pl}} +
- +
-Baza wiedzy: {{animal_kb.pl}} +
- +
-=== - System: XSHELL === +
-Źródło: Michael A. Covington, Donald Nute and André Vellino, //Prolog programming in depth//, Prentice-Hall,​ 1996. +
- +
-Cechy: +
-    * klauzule Prologu jako reprezentacja wiedzy +
-    * rozbudowana reprezentacja reguł +
-    * wbudowany mechanizm Prologu +
-    * wnioskowanie wstecz +
-    * wymienne bazy wiedzy +
-    * rozbudowane przetwarzanie +
-Mechanizm wnioskujący:​ {{xshell.pl}} +
- +
-Baza wiedzy: {{cichlid.pl}} +
- +
-Pliki pomocnicze: {{readstr.pl}} , {{readnum.pl}} , {{writeln.pl}} , {{getyesno.pl}} +
- +
-===== - #5 ĆWICZENIA ===== +
- +
-==== - Ćwiczenie: Sprawdzanie typów termów ====+
  
 Proszę przetestować poniższe: Proszę przetestować poniższe:
Linia 206: Linia 54:
 ?- number(3). ?- number(3).
  
-?- number(3). 
 ?- integer(3). ?- integer(3).
 ?- integer(3.14). ?- integer(3.14).
-?- float(3.14). 
 ?- float(3). ?- float(3).
 +?- float(3.14).
  
 ?- compound(ala). ?- compound(ala).
Linia 219: Linia 66:
 Uwaga: ''​compound''​ nie nadaje się do "​wykrywania"​ list, bo: Uwaga: ''​compound''​ nie nadaje się do "​wykrywania"​ list, bo:
 <code prolog> <code prolog>
-?- compound([]).+?-  compound([]).
 </​code>​ </​code>​
  
  
  
 +===== - Temat: Konstruowanie i dekompozycja termów =====
  
-==== - Ćwiczenie: ​Konstruowanie i dekompozycja termów ====+ 
 +Z racji tego, iż termy sa podstawową metodą strukturalizacji danych w Prolog, istnieje kilka mechanizmów wspomagających ich przetwarzanie:​ 
 + 
 +  ​=.. 
 +operator pozwala na dynamiczną zamianę termu na listę i vice versa  
 +  functor(T,​N,​A) 
 +predykat jest prawdziwy, jeżeli N pokrywa się z nazwą termu T o arności A  
 +  arg(N,​T,​A) 
 +predykat jest prawdziwy, jeżeli A jest Ntym argumentem termu T  
 + 
 +**  ​Ćwiczenie:** 
  
 Proszę przećwiczyć przetwarzanie termów: Proszę przećwiczyć przetwarzanie termów:
  
 <code prolog> <code prolog>
-?- A =.. [ala, ma, kota].+?- A =.. [ala, ma, asa].
 ?- ala(ma,​kota,​w(ciapki(rozowe))) =.. A. ?- ala(ma,​kota,​w(ciapki(rozowe))) =.. A.
 </​code>​ </​code>​
Linia 239: Linia 97:
 ?- functor(ala(ma,​kota),​F,​A). ?- functor(ala(ma,​kota),​F,​A).
  
-?- CzyTo=ala,​OLiczbie=2,​functor(ala(ma,​kota),​CzyTo,​OLiczbie).+?- CzyTo = ala, OLiczbie = 2, functor(ala(ma,​kota),​CzyTo,​OLiczbie).
  
-?- CzyTo=kasia,​OLiczbie=2,​functor(ala(ma,​kota),​CzyTo,​OLiczbie).+?- CzyTo = kasia, OLiczbie = 2, functor(ala(ma,​kota),​CzyTo,​OLiczbie).
  
 ?- functor(ala(ma,​kota),​F,​_),​ write('​To jest funktor \''​),​ write(F), write('​\'​.'​). ?- functor(ala(ma,​kota),​F,​_),​ write('​To jest funktor \''​),​ write(F), write('​\'​.'​).
Linia 258: Linia 116:
 a(1). a(2). b(4). b(3). a(1). a(2). b(4). b(3).
  
-wyp0(F,_):-+wyp0(F,_) :-
   call(F).   call(F).
  
-wyp1(F,X):-+wyp1(F,X) :-
   F,   F,
   F =.. [_,X].   F =.. [_,X].
  
-wyp2(F,X):-+wyp2(F,X) :-
   functor(Pred,​F,​1),​   functor(Pred,​F,​1),​
   Pred,   Pred,
   Pred =.. [_,X].   Pred =.. [_,X].
  
-wyp3(F/​A,​X):​-+wyp3(F/A,X) :-
   A = 1,   A = 1,
   functor(Pred,​F,​A),​   functor(Pred,​F,​A),​
Linia 279: Linia 137:
 Wykonaj zapytania będące przykładami użycia powyższych predykatów:​ Wykonaj zapytania będące przykładami użycia powyższych predykatów:​
 <code prolog> <code prolog>
-?​-wyp0(a(X),​X). +?- wyp0(a(X),​X). 
-?​-wyp0(b(X),​X).+?- wyp0(b(X),​X).
  
-?​-wyp1(a(_),​X). +?- wyp1(a(_),​X). 
-?​-wyp1(b(_),​X).+?- wyp1(b(_),​X).
  
-?​-wyp2(a,​X). +?- wyp2(a,​X). 
-?​-wyp2(b,​X).+?- wyp2(b,X).
  
-?​-wyp3(a/​1,​X). +?- wyp3(a/​1,​X). 
-?​-wyp3(b/​1,​X).+?- wyp3(b/​1,​X).
 </​code>​ </​code>​
  
-==== - Ćwiczenie: Definiowanie operatorów ====+ 
 +===== - Temat: Definiowanie operatorów ===== 
 + 
 + 
 +W prologu bardzo łatwo można definiować własne operatory, co ułatwia przetwarzanie danych. 
 + 
 +Realizowane jest to przez predykat :- op(P, T, N), który definiuje N, jako operator typu T, o priorytecie P. 
 +Zobacz:  
 +  * http://​www.swi-prolog.org/​pldoc/​man?​predicate=op/​3 
 +  * http://​www.learnprolognow.org/​lpnpage.php?​pagetype=html&​pageid=lpn-htmlse40 
 + 
 +Zdefiniowane w standardzie ISO operatory to: 
 + 
 +<​code>​ 
 +1200 xfx -->,​ :- 
 +1200 fx :-, ?- 
 +1150 fx dynamic,​ discontiguous,​ initialization,​ module_transparent,​ multifile, thread_local,​ volatile 
 +1100 xfy ;, | 
 +1050 xfy ->,​ op*-> 
 +1000 xfy ,​ 
 +954 xfy \ 
 +900 fy \+ 
 +900 fx ~ 
 +700 xfx <,​ =, =.., =@=, =:=, =<, ==, =\=, >, >=, @<, @=<, @>, @>=, \=, \==, is 
 +600 xfy : 
 +500 yfx +, -, /\, \/, xor 
 +500 fx +, -, ?, \ 
 +400 yfx *, /, //, rdiv, <<, >>, mod, rem 
 +200 xfx ** 
 +200 xfy ^ 
 +</​code>​ 
 + 
 +Wszystkie mogą być zredefiniowane!. 
 + 
 +Gdyby nie operatory, to prosty program w Prologu: 
 + 
 +<code prolog>​ 
 +go :- write('​Hello '), write('​World\n'​). 
 + 
 +:- go. 
 +</​code>​ 
 + 
 +Musialby wyglądać następująco (wszytko w notacji prefiksowej,​ zapisane jako termy): 
 + 
 +<code prolog>​ 
 +:- (go,','​(write('​Hello '), write('​World\n'​))). 
 + 
 +:- (go). 
 +</​code>​ 
 + 
 +Uwaga: obydwa programy są równoważne. W drugim programie widać, że klauzule złożone również zapisane są jako termy. 
 + 
 +Patrz również:​ 
 +  * [[http://​cs.union.edu/​~striegnk/​learn-prolog-now/​html/​node84.html#​subsec.l9.operators.def|Lean Prolog Now]] 
 + 
 +** Ćwiczenie: ​ ** 
  
 Proszę wpisać do pliku oper1.pl Proszę wpisać do pliku oper1.pl
Linia 308: Linia 221:
 :- op(300, xfx, ma). :- op(300, xfx, ma).
 :- op(200, xfy, i). :- op(200, xfy, i).
 +
 jas ma kota i psa. jas ma kota i psa.
 ala ma jasia i angine i dosc_agh. ala ma jasia i angine i dosc_agh.
Linia 322: Linia 236:
 ?- ma(A,​i(B,​i(C,​D))). ?- ma(A,​i(B,​i(C,​D))).
  
-?-Kto ma Co.+?- Kto ma Co.
  
-?-Kto ma Co i Cosinnego.+?- Kto ma Co i Cosinnego.
  
-?-Kto ma Cos i CosInnego i Jeszcze.+?- Kto ma Cos i CosInnego i Jeszcze.
  
 ?- display(jas ma kota i psa). ?- display(jas ma kota i psa).
Linia 335: Linia 249:
 Co zwróci poniższe zapytanie? Co zwróci poniższe zapytanie?
 <code prolog> <code prolog>
-?- i(X,B).+?- i(A,B).
 </​code>​ </​code>​
 Podpowiedź:​ zwróć uwagę na priorytety operatorów. Podpowiedź:​ zwróć uwagę na priorytety operatorów.
  
-==== - Ćwiczenie: Konstruowanie klauzul i Metainterpretery ====+ 
 +===== - Temat: Konstruowanie klauzul i Metainterpretery ===== 
 + 
 + 
 +W Prologu występują dwa silne mechnizmy wspomagające metainterpretację kodu: 
 + 
 +  call(X) 
 +wywołuje X, jako cel Prologu,  
 +  clause(Head,​Body) 
 +odszukuje klauzulę o nagłówku Head, gdzie Body jest unifikowane z ciałem klauzuli; w przypadku faktów Body=true.  
 + 
 +Meta programowanie to tworzenie programów, które przetwarzają kod innych programów. Przykłady metaprogramowania znaleźć można w np.: kompilatorach,​ analizatorach kodu, generatorach kodu. W Prologu metaprogramowanie jest naturalną techniką, dzięki czemu pisanie programów działających w diametralnie różnych paradygmatach jest proste. 
 + 
 + 
 +** Ćwiczenie: ** 
  
  
Linia 353: Linia 281:
  
 ?- listing(matka). ?- listing(matka).
-?- Kto=kasia, call(matka(Kto,​Kogo)),​ write(Kto), write('​ jest matka '), write(Kogo). +?- Kto = kasia, call(matka(Kto,​Kogo)),​ write(Kto), write('​ jest matka '), write(Kogo). 
-?- Matka=kasia,​ Dziecko=robert,​ clause(matka(Matka,​Dziecko),​Kiedy),​ write(Matka),​ write('​ jest matka '), write(Dziecko),​ write('​ wtedy gdy: '), write(Kiedy).+?- Matka = kasia, Dziecko = robert, clause(matka(Matka,​Dziecko),​Kiedy),​ write(Matka),​ write('​ jest matka '), write(Dziecko),​ write('​ wtedy gdy: '), write(Kiedy).
 </​code>​ </​code>​
  
Linia 370: Linia 298:
  display(Q),​  display(Q),​
  call(Q),  call(Q),
- write(Kto),​ + write(Kto),​ nl.
- nl.+
 </​code>​ </​code>​
  
Linia 377: Linia 304:
  
 a następnie przetestować i przemyśleć:​ a następnie przetestować i przemyśleć:​
- 
  
 <code prolog> <code prolog>
 ?- odpowiedz. ?- odpowiedz.
 +
 '​matka'​ czy '​ojciec'?​ ojciec '​matka'​ czy '​ojciec'?​ ojciec
 kogo? robert kogo? robert
Linia 403: Linia 330:
  rozwiaz3(G2).  rozwiaz3(G2).
 rozwiaz3(G) :- rozwiaz3(G) :-
- write('​Wywoluje:​ '), write(G), nl,+ write('​Wywoluje: ​ '), write(G), nl,
  clause(G,​B),​  clause(G,​B),​
  rozwiaz3(B),​  rozwiaz3(B),​
- write('​Wyjscie: ​ '), write(G), nl.+ write('​Wyjscie: ​  ​'), write(G), nl.
 </​code>​ </​code>​
  
Linia 420: Linia 347:
 ?- rozwiaz1(matka(kasia,​X)). ?- rozwiaz1(matka(kasia,​X)).
  
-?- rozwiaz1((matka(kasia,​X),​matka(Y,​robert))).+?- rozwiaz1((matka(kasia,​X),​ matka(Y,​robert))).
  
-?- rozwiaz2((matka(kasia,​X),​matka(Y,​robert))).+?- rozwiaz2((matka(kasia,​X),​ matka(Y,​robert))).
  
-?- rozwiaz3((matka(kasia,​X),​matka(Y,​robert))).+?- rozwiaz3((matka(kasia,​X),​ matka(Y,​robert))).
 </​code>​ </​code>​
  
Linia 434: Linia 361:
  
  
-==== - Ćwiczenie: Przykłady systemów ekspertowych ==== 
  
 +===== - Temat: Systemy ekspertowe =====
  
-Przetestować ​systemy:+W Prologu niezwykle prosto tworzy się systemy ekspertowe. 
 + 
 +W systemie ekspertowym można wyróżnić następujące elementy: 
 + 
 +  * baza wiedzy, czasami dzielona na: właściwą bazę wiedzy (czyli tą którą system dysponuje stale, od początku/​uruchomienia) i bazę faktów, które system odkrywa, dostaje, wypracowuje,​  
 +  * mechanizm wnioskujący,​ który przeprowadza właściwy proces wnioskowania,​ tj. odnajduje rozwiązanie/​odpowiedź  
 +  * mechanizm wyjaśniający,​ dlaczego jest to odpowiedź poprawna/​dopuszczalna,​  
 +  * interfejs użytkownika,​ pozwalający na komunikację z systemem.  
 + 
 +Rysunek 1: Struktura Systemu Ekspertowego. 
 + 
 +{{expert-systems-arch.png}} 
 + 
 +Poniżej podane są przykłady różnych systemów. 
 + 
 + 
 +==== - System: CAR ==== 
 + 
 +Źródło: Michael A. Covington, Donald Nute and André Vellino, //Prolog programming in depth//, Prentice-Hall,​ 1996. 
 + 
 +Cechy: 
 +    * klauzule Prologu jako reprezentacja wiedzy 
 +    * wbudowany mechanizm Prologu 
 +    * wnioskowanie wstecz (abdukcja) ((Backward chaining inference, goal driven inference - stosowane w systemach diagnostycznych,​ w którym mamy ograniczoną (niewielką) liczbę możliwych hipotez, system stara się dowieść każdej z nich po kolei, zbierając informacje "po drodze"​)) 
 +    * trywialny :-) 
 +System: {{car.pl}} 
 +Dodatkowo korzysta on z pliku {{getyesno.pl}} 
 + 
 +Przetestować ​działanie systemu.  
 +System diagnozuje przyczyną awarii samochodu. 
 + 
 +W przypadku tego systemu elementy systemu ekspertowego są odwzorowane przez: 
 + 
 +  * predykat //​defect_may_be/​1//​ -> baza wiedzy 
 +  * predykat //​try_all_possibilities/​0//​ oraz mechanizm wnioskujący Prologu -> mechanizm wnioskujący 
 +  * predykat //​explain/​1//​ -> mechanizm wyjaśniania 
 +  * predykaty //​ask_question/​1//​ i //​user_says/​2//​ -> interfejs użytkownika
  
-  * System: CAR 
 System: {{car.pl}} System: {{car.pl}}
  
 Plik pomocniczy: ​ {{getyesno.pl}} Plik pomocniczy: ​ {{getyesno.pl}}
  
-  * System: ​OOPS +==== - System: ​BIRDS ==== 
-Mechanizm wnioskujący: {{oops.pl}}, +Źródło: Dennis Merritt, //​[[http://​www.amzi.com/​ExpertSystemsInProlog/​|Building Expert Systems in Prolog]]//, Springer-Verlag,​ 1989.
  
-Baza wiedzy: {{animal_kb.pl}}+Cechy: 
 +    * prologowa reprezentacja reguł 
 +    * własny mechanizm wnioskujący - metainterpreter 
 +    * wnioskowanie wprzód ((Forward chaining inference, data driven inference - stosowane w celu uniknięcia eksplozji kombinatorycznej,​ gdy możliwe jest (nieskończenie) wiele poprawnych odpowiedzi, system na podstawie danych "​odpala"​ odpowiednie reguły)) 
 +    * wymienne bazy wiedzy
  
-  ​* System: XSHELL+Mechanizm wnioskujący:​ {{native.pl}} 
 + 
 +Bazy wiedzy: {{birds_kb.pl}} 
 + 
 +Uruchomienie:​ załadować //​native.pl//​ i wywołać ''​main.''​ 
 + 
 + 
 +==== - System: OOPS ==== 
 + 
 +Źródło: Dennis Merritt, //​[[http://​www.amzi.com/​ExpertSystemsInProlog/​|Building Expert Systems in Prolog]]//, Springer-Verlag,​ 1989. 
 + 
 +Cechy: 
 +    ​* własna reprezentacja reguł 
 +    * kodowanie reguł na termach Prologu 
 +    * własny mechanizm wnioskujący 
 +    * wnioskowanie wprzód 
 +    * wymienne bazy wiedzy 
 + 
 +Mechanizm wnioskujący:​ {{oops.pl}} 
 + 
 +Bazy wiedzy: {{room_kb.pl}} {{animal_kb.pl}} 
 + 
 +Uruchomienie:​ załadować //oops.pl// i wywołać ''​main.''​ 
 + 
 + 
 +==== - System: XSHELL ​==== 
 +Źródło: Michael A. Covington, Donald Nute and André Vellino, //​[[http://​www.covingtoninnovations.com/​books.html#​ppid|Prolog programming in depth]]//, Prentice-Hall,​ 1996. 
 + 
 +Cechy: 
 +    * klauzule Prologu jako reprezentacja wiedzy 
 +    * rozbudowana reprezentacja reguł 
 +    * wbudowany mechanizm Prologu 
 +    * wnioskowanie wstecz 
 +    * wymienne bazy wiedzy 
 +    * rozbudowane przetwarzanie
 Mechanizm wnioskujący:​ {{xshell.pl}} Mechanizm wnioskujący:​ {{xshell.pl}}
 +
 +Baza wiedzy: {{cichlid.pl}}
  
 Pliki pomocnicze: {{readstr.pl}} , {{readnum.pl}} , {{writeln.pl}} , {{getyesno.pl}} Pliki pomocnicze: {{readstr.pl}} , {{readnum.pl}} , {{writeln.pl}} , {{getyesno.pl}}
  
-Baza wiedzy: ​{{cichlid.pl}}+Należy załadować plik z bazą wiedzy ​(ten z kolei ładuje mechanizm wnioskujący) i użyć predykatu ''​xshell.''​ 
 + 
 +**Ćwiczenie: ** 
 + 
 +Przetestuj powyższe systemy.
  
 Analizując ich pracę i sposób implementacji,​ proszę zwrócić uwagę na: Analizując ich pracę i sposób implementacji,​ proszę zwrócić uwagę na:
Linia 460: Linia 466:
   * sposób reprezentacji reguł, jak są zapisywane reguły w bazie wiedzy systemu, z jakich operatorów korzystają,​   * sposób reprezentacji reguł, jak są zapisywane reguły w bazie wiedzy systemu, z jakich operatorów korzystają,​
   * sposób implementacji mechanizmy wnioskującego,​ na jakich rozwiązaniach się opiera.   * sposób implementacji mechanizmy wnioskującego,​ na jakich rozwiązaniach się opiera.
 +
 +====== Temat: własne systemy ======
 +Zbuduj bazę wiedzy dla własnego systemu regułowego (dla wybranej implementacji).
 +Propozycje dziedzin podane są poniżej.
 +
 +System rozpoznaje psy.
 +Należy opisać kilka/​naście znanych ras psów na podstawie: [[http://​pl.wikipedia.org/​wiki/​Grupy_FCI]],​ [[http://​atlaspsow.w.interia.pl]],​ [[http://​rasy-psow.com]],​ [[http://​www.psy.elk.pl/​rasypsow/​]].
 +Warto wybrać przedstawicieli z różnych grup FCI.
 +
 +W celu identyfikacji rasy trzeba wybrać kilka podstawowych cech, w tym płeć (powiązana z rozmiarem!),​ wagę, rozmiar, umaszczenie,​ kształt głowy, uszy, etc.
 +
 +Podobny do w.w. system rozpoznający ptaki występujące w Polsce.
 +Należy oprzeć się na:
 +[[http://​ptaki.luzik.proste.pl]],​ [[http://​ptaki.zwierzeta.ekologia.pl]].
  
 ====== Uwagi, komentarze, propozycje ====== ====== Uwagi, komentarze, propozycje ======
-Tu studenci mogą wpisywać swoje uwagi.+Tu studenci mogą wpisywać swoje uwagi...
  
  --- //​[[gjn@agh.edu.pl|Grzegorz J. Nalepa]] 2009/05/06 09:13//  --- //​[[gjn@agh.edu.pl|Grzegorz J. Nalepa]] 2009/05/06 09:13//
 +
pl/prolog/prolog_lab/prolog_lab_metaprog.1262762654.txt.gz · ostatnio zmienione: 2019/06/27 15:59 (edycja zewnętrzna)
Pokaż stronęPoprzednie wersje
Menadżer multimediówDo góry
www.chimeric.de Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0