Both sides previous revision
Poprzednia wersja
Nowa wersja
|
Poprzednia wersja
|
pl:prolog:prolog_lab:prolog_lab_metaprog [2010/06/09 13:15] ikaf |
pl:prolog:prolog_lab:prolog_lab_metaprog [2017/04/05 12:26] esimon [3 Temat: Definiowanie operatorów] |
====== - 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. |
| |
<code prolog> | <code prolog> |
var(X) | var(X). |
nonvar(X) | nonvar(X). |
</code> | </code> |
| |
liczbą zmiennoprzecinkową | liczbą zmiennoprzecinkową |
| |
==== - Temat: Konstruowanie i dekompozycja 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: |
?- 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). |
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> |
?- 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('\'.'). |
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), |
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 |
:- 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. |
?- 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). |
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: ** |
| |
| |
| |
?- 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> |
| |
display(Q), | display(Q), |
call(Q), | call(Q), |
write(Kto), | write(Kto), nl. |
nl. | |
</code> | </code> |
| |
| |
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 |
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> |
| |
?- 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> |
| |
| |
| |
==== - Ć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: |
* 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// |
| |