CLIPS - wprowadzenie

CLIPS - wprowadzenie
Witold Paluszyński
[email protected]
http://sequoia.ict.pwr.wroc.pl/∼ witold/
c 2003-2008 Witold Paluszyński
Copyright All rights reserved.
Niniejszy dokument zawiera materialy do wykladu na temat programowania
w je֒ zyku CLIPS. Jest on udoste֒ pniony pod warunkiem wykorzystania wyla֒cznie
do wlasnych, prywatnych potrzeb i może być kopiowany wyla֒cznie w calości,
razem z niniejsza֒ strona֒ tytulowa֒.
Regulowe systemy produkcji
Regulowe systemy produkcji sa֒ jednym z ważnych paradygmatów konstrukcji
praktycznych systemów sztucznej inteligencji, gdzie wiedza systemu jest zebrana
w postaci zestawu regul produkcji. Każda z tych regul przedstawia soba֒
pojedynczy fakt skojarzeniowy skladaja֒cy sie֒ z zalożeń i wniosków. Proces
wnioskowania przeprowadzany jest przez calkowicie ogólna֒ procedure֒ , która
rozumie jedynie strukture֒ (a nie treść) regul i potrafi wybierać odpowiednie
reguly i prowadzić wnioskowanie kieruja֒c sie֒ calkowicie ogólnymi strategiami.
'
$
$
?
?
PR:
Pamieć
֒ robocza
(lista faktów i obiektów)
PP
PP
PP
PP
PP
q
BW:
Baza wiedzy
(lista regul produkcji)
)
UW:
Urza֒dzenie wnioskuja֒ce
(interpreter regul produkcji)
&
Regulowe systemy produkcji
zmiany
%
1
Cykl roboczy systemu produkcji
Praca systemu produkcji polega na cyklicznym wybieraniu i wykonywaniu jednej
reguly, której cześć
֒ warunkowa jest spelniona przez aktualna֒ zawartość pamie֒ ci
roboczej PR. Taki schemat nazywany jest schematem rozpoznaj-dzialaj
(recognize-act cycle). Realizuje go element wykonawczy, urza֒dzenie wnioskuja֒ce
UW. Jest to interpreter regul produkcji, który poza ogólna֒ strategia֒ wyboru,
zna jedynie skladnie֒ regul i potrafi je wykonywać.
PR := opis stanu pocza֒tkowego
'
?
ZK := zbiór produkcji ze spelnionymi warunkami
(jeśli pusty to system kończy prace֒ )
?
R := regula wybrana ze ZK zgodnie ze strategia֒
?
wykonanie reguly R: PR := R(PR), BW := R(BW)
&
Regulowe systemy produkcji
%
2
Po wste֒ pnym wpisaniu danych pocza֒tkowych do pamie֒ ci roboczej, w pierwszym
kroku cyklu roboczego UW bada cześ
֒ ci warunkowe wszystkich regul. Te,
których warunki sa֒ spelnione tworza֒ tzw. zbiór konfliktowy ZK (conflict set).
Konflikt wynika z faktu, że tylko jedna regula może być wybrana do wykonania.
W drugim kroku interpreter regul wybiera jedna֒ regule֒ ze zbioru konfliktowego,
by naste֒ pnie w kroku trzecim ja֒ wykonać. Wykonywanie reguly nazywane jest
jej odpalaniem. Sposób wyboru reguly do odpalenia, zwany strategia֒, może być
różny w różnych realizacjach systemów produkcji, natomiast sposób i skutki
odpalenia reguly określa jej cześć
֒ wykonawcza, zwana ”akcja”
֒ . Akcja może
dodawać, usuwać, lub modyfikować dane w pamie֒ ci roboczej. Może również
spowodować jakiś efekt uboczny typu operacji I/O na urza֒dzeniu zewne֒ trznym.
W niektórych realizacjach systemów produkcji akcje moga֒ również modyfikować
reguly BW (dodawać, usuwać). Jest to równoważne samomodyfikacji programu.
Regulowe systemy produkcji
3
CLIPS: wprowadzenie
CLIPS jest narze֒ dziem do budowy i osadzania systemów
doradczych opartych o reprezentacje֒ regulowa֒, ale umożliwia również wykorzystanie programowania proceduralnego i obiektowego. Ze wzgle֒ du na doste֒ pność w wersji
źródlowej jest możliwe zarówno importowanie zewne֒ trznych procedur napisanych w C, jak i zanurzanie aplikacji
napisanych w CLIPS-ie w innych programach.
Pierwsza wersja CLIPSa zostala napisana w polowie lat 80-tych (ubieglego
wieku) w ośrodku NASA Johnson Space Center. Jego pierwotnym
przeznaczeniem bylo pisanie systemów wspomagaja֒cych podejmowanie decyzji
dotycza֒cych planowania lotów promów kosmicznych. CLIPS byl prawie od
pocza֒tku doste֒ pny w źródle dla zainteresowanych, choć przez szereg lat NASA
sprzedawala licencje do zastosowań komercyjnych. Obecnie NASA pozbyla sie֒
praw i obowia֒zków zwia֒zanych z CLIPS-em i jest on doste֒ pny na zasadzie
public domain dla dowolnych zastosowań.
CLIPS — wprowadzenie
4
CLIPS: fakty proste
Proste fakty nie maja֒ żadnej struktury, istotny jest w nich tylko porza֒dek.
Dlatego sa֒ również nazywane faktami uporza֒dkowanymi (ordered facts).
Definiujemy je funkcja֒ assert:
(assert (jas))
(assert (ma jas klocki))
(assert (ma jas malgosia))
(facts)
(clear) ;
;
;
(reset) ;
;
;
(exit) ;
kasuje wszystko,
przywraca stan
poczatkowy Clipsa
kasuje efekty
dzialania programu,
umozliwia restart
konczy prace CLIPSa
CLIPS — wprowadzenie
sierra-41> clips
CLIPS (V6.10 07/01/98)
CLIPS> (assert (jas))
<Fact-0>
CLIPS> (assert (ma jas klocki))
<Fact-1>
CLIPS> (assert (ma jas malgosia))
<Fact-2>
CLIPS> (facts)
f-0
(jas)
f-1
(ma jas klocki)
f-2
(ma jas malgosia)
For a total of 3 facts.
CLIPS> (clear)
CLIPS> (facts)
CLIPS> (exit)
sierra-42>
5
Zasady budowania faktów prostych
Kolejne elementy listy tworza֒cej fakt prosty sa֒ polami, których znaczenie jest
glównie pozycyjne. Z pewnych wzgle֒ dów najważniejsze jest pierwsze pole, w
którym normalnie umieszcza sie֒ symbol relacji wiaż
֒ a֒cej dalsze pola. Przy
systematycznym budowaniu zestawu faktów można przypisać konkretne pozycje
do cech lub zestawów cech, które na danej pozycji moglyby wysta֒pić. Można
stosować wartości typu nic” tylko dlatego, że wcześniejsze pole musi coś
”
zawierać, jeśli ważne sa֒ dalsze pola.
(assert
(assert
(assert
(assert
(assert
(assert
(ma jas
(ma jas
(ma jas
(jas ma
(ma jas
(ma jas
kolekcja motyli))
; dobrze
kolekcja tropikalnych motyli)) ; zle
kolekcja motyli tropikalnych)) ; lepiej
ciekawa kolekcja tropikalnych motyli)) ; zle
hodowle motyli))
- motyli))
; kolekcje/hodowle/encyklopedie
Jak wkrótce zobaczymy, istnieja֒ w CLIPSie konstrukcje, które nadaja֒ sie֒ do
wyrażania zjawisk o skomplikowanej strukturze lepiej niż fakty proste.
CLIPS — wprowadzenie
6
Fakty uporza֒dkowane nie moga֒ mieć struktury, ale wywolania CLIPSa moga֒ być
zlożone i zawierać wywolania funkcji:
CLIPS> (assert (ma jas (kolekcja motyli)))
[EXPRNPSR3] Missing function declaration for kolekcja.
CLIPS> (assert (ma jas (+ 3 4) lat))
<Fact-0>
CLIPS> (facts)
f-0
(ma jas 7 lat)
For a total of 1 fact.
Jak już zauważyliśmy, fakty otrzymuja֒ chronologiczne indeksy o postaci typu:
f-0, f-1, itp. Indeksy te pozwalaja֒ odnosić sie֒ do konkretnego faktu, np. w celu
jego skasowania:
(retract 1)
(retract *)
; niebezpieczne
Chronologia faktów jest istotna w dzialaniu programów, na przyklad jest
wykorzystywana jako element strategii.
CLIPS — wprowadzenie
7
CLIPS — wprowadzenie
8
Reguly
CLIPS pozwala na definiowanie regul zawieraja֒cych warunki i akcje. Regula
której warunek jest spelniony przez aktualny zbiór faktów może zostać w każdej
chwili odpalona” przez CLIPS, tzn. jej akcja wykonana. Akcje regul moga֒
”
dodawać, usuwać lub zmieniać fakty, wyświetlać na terminalu, wykonywac
operacje na plikach, a także tworzyć nowe reguly.
(defrule beztroska
(ma jas kolekcja motyli)
=>
(assert (ma jas szczesliwe-dziecinstwo)))
(defrule niestety
(ma jas kolezanka malgosia)
=>
(assert (ma jas klopoty)))
CLIPS — wprowadzenie
9
Śledzenie zmian w pamieci
roboczej
֒
Funkcja watch pozwala śledzić zmiany zachodza֒ce w środowisku roboczym w
trakcie pracy programu. Nie jest to potrzebne przy tworzeniu lub kasowaniu
faktów z palca” lecz przy uruchamianiu regul staje sie֒ cennym narze֒ dziem:
”
CLIPS> (assert (ma jas kolega zdzich))
<Fact-0>
CLIPS> (watch facts)
CLIPS> (assert (ma jas kolezanka malgosia))
==> f-1
(ma jas kolezanka malgosia)
<Fact-1>
CLIPS> (retract 0)
<== f-0
(ma jas kolega zdzich)
CLIPS — wprowadzenie
10
Uruchamianie systemu regulowego
CLIPS> (defrule beztroska
(ma jas kolekcja motyli)
=>
(assert (ma jas szczesliwe-dziecinstwo)))
CLIPS> (defrule niestety
(ma jas kolezanka malgosia)
=>
(assert (ma jas klopoty)))
CLIPS> (rules)
beztroska
niestety
For a total of 2 defrules.
CLIPS> (assert (ma jas kolekcja motyli))
<Fact-0>
CLIPS> (assert (ma jas kolezanka malgosia))
<Fact-1>
CLIPS> (agenda)
0
niestety: f-1
0
beztroska: f-0
For a total of 2 activations.
CLIPS> (watch facts)
CLIPS — wprowadzenie
11
CLIPS> (run)
==> f-2
(ma jas klopoty)
==> f-3
(ma jas szczesliwe-dziecinstwo)
CLIPS> (facts)
f-0
(ma jas kolekcja motyli)
f-1
(ma jas kolezanka malgosia)
f-2
(ma jas klopoty)
f-3
(ma jas szczesliwe-dziecinstwo)
For a total of 4 facts.
CLIPS> (unwatch facts)
CLIPS> (reset)
CLIPS> (rules)
beztroska
niestety
For a total of 2 defrules.
CLIPS> (facts)
f-0
(initial-fact)
For a total of 1 fact.
CLIPS> (clear)
CLIPS> (rules)
CLIPS> (exit)
CLIPS — wprowadzenie
12
Wzorce
Reguly moga֒ zawierać w cześ
֒ ci warunkowej wzorce, pozwalaja֒ce wyrażać pewne
zależności ogólne. Wzorce zwykle wprowadzaja֒ zmienne, zapisywane ze znakiem
zapytania, co pozwala tworzyć akcje zależne od konkretnej postaci faktu
dopasowanego do danego wzorca. Zakresem zmiennej jest zawieraja֒ca go regula.
(defrule lubi-to-co-ma
(ma ?x ?y)
=>
(assert (lubi ?x ?y)))
(defrule lubi-to-co-ma-2
(ma ?x ?y $?z)
=>
(assert (lubi ?x ?y ?z)))
(defrule szczesliwy-ten-co-ma-co-lubi
(ma ?x ?y $?)
(lubi ?x ?y $?)
=>
(assert (szczesliwy ?x)))
Poza zwyklymi zmiennymi, Clips posiada zmienne wielopozycyjne”, zapisywane
”
z dodatkowym znakiem dolara, pod które dopasowuje cia֒gi n-elementowe (0 lub
wie֒ cej).
CLIPS — wprowadzenie
13
Wzorcami moga֒ być fakty, ale moga֒ być również wyrażenia warunkowe
obliczane przez Clips, zapisywane z wywolaniem funkcji test.
(defrule niestety-2
(ma ?x kolezanka ?y)
(wiek ?y ?z)
(test (> ?z 16))
=>
(assert (ma ?x klopoty)))
(defrule klopoty-biora-gore
(ma ?x klopoty)
?f <- (szczesliwy ?x)
=>
(retract ?f))
CLIPS — wprowadzenie
14
Przydatne funkcje pomocnicze
Spróbujmy teraz uruchomić jakieś proste reguly na utworzonych przykladowych
faktach. Aby ulatwić sobie wielokrotne powtarzanie danego ćwiczenia, warto
pewne konstrukcje zapamie֒ tać w pliku dyskowym.
Zestaw definicji regul możemy zapisać na pliku i ladować je do CLIPSa funkcja֒
load. Z jakichś powodów nie możemy tak samo posta֒pić z deklaracjami
tworzenia faktów assert, lecz jest to możliwe dla konstrukcji deffacts, nawet
bardziej przydatnej.
(defrule lubi-co-ma-2
(ma ?x ?y $?z)
=>
(assert (lubi ?x ?y ?z)))
(deffacts koledzy-jasia
(ma jas kolega zdzich)
(ma jas kolezanka malgosia)
(ma jas kolekcja motyli)
(wiek jas 15))
CLIPS — wprowadzenie
15
CLIPS> (load "konstrukcje.clips")
CLIPS> (facts)
CLIPS> (reset)
CLIPS> (facts)
f-0
(initial-fact)
f-1
(ma jas kolega zdzich)
f-2
(ma jas kolezanka malgosia)
f-3
(ma jas kolekcja motyli)
f-4
(wiek jas 15)
For a total of 5 facts.
CLIPS> (run)
CLIPS> (facts)
f-0
(initial-fact)
f-1
(ma jas kolega zdzich)
f-2
(ma jas kolezanka malgosia)
f-3
(ma jas kolekcja motyli)
f-4
(wiek jas 15)
f-5
(lubi jas kolekcja motyli)
f-6
(lubi jas kolezanka malgosia)
f-7
(lubi jas kolega zdzich)
For a total of 8 facts.
CLIPS> (exit)
CLIPS — wprowadzenie
16
Przyklad: Jaś i klopoty
Poniższy przyklad pokazuje prosty system wycia֒gaja֒cy wnioski z malego
zestawu faktów. Niestety, wnioski sa֒ czasami zbyt daleko ida֒ce (np. że Jaś lubi
swoje klopoty, albo, że jest szcześ
֒ liwy gdy jednocześnie ma klopoty). Konieczne
jest uwgle֒ dnianie takich wyja֒tków albo przez uszczególowienie reguly, albo
przez dodanie innej reguly koryguja֒cej już wycia֒gnie֒ te wnioski.
(deffacts jas_przyjaciele
(ma jas kolega zdzich)
(wiek zdzich 18)
(ma jas kolega rychu)
(wiek rychu 19)
(ma jas kolezanka malgosia)
(wiek malgosia 17))
(defrule niestety-2
(ma ?x kolezanka ?y)
(wiek ?y ?z)
(test (> ?z 16))
=>
(assert (ma ?x klopoty)))
CLIPS — wprowadzenie
17
;;;(defrule
;;;
;;;
;;; =>
;;;
lubi-to-co-ma-2a
(ma ?x ?y $?z)
(test (not (eq ?y klopoty)))
(assert (lubi ?x ?y ?z)))
(defrule lubi-to-co-ma-2b
(ma ?x ?y&~klopoty $?z)
=>
(assert (lubi ?x ?y ?z)))
(defrule szczesliwy-ten-co-ma-co-lubi
(ma ?x ?y $?)
(lubi ?x ?y $?)
=>
(assert (szczesliwy ?x)))
(defrule klopoty-biora-gore
(ma ?x klopoty)
?f <- (szczesliwy ?x)
=>
(retract ?f))
CLIPS — wprowadzenie
18
Dalsze funkcje wspomagajace
debuggowanie i inne
֒
(set break <nazwa-reguly>)
(remove-break <nazwa-reguly>)
(show-breaks)
(agenda)
; wyswietla zestaw regul mozliwych do odpalenia
(matches <nazwa-reguly>) ; wyswietla fakty spelniajace warunki reguly
(ppdefrule <nazwa-reguly>) ; wyswietla "pieknie" sformatowana regule
(list-defrules)
(save "nazwa-pliku")
(read)
; czyta jedno slowo z wejscia, zwraca jako symbol
(readline)
; czyta jeden wiersz z wejscia, zwraca jako string
(printout t "Wartosc zmiennej: " ?x crlf crlf)
CLIPS — wprowadzenie
19
Fakty strukturalne deftemplate
Fakty deftemplate trzeba zdefiniować przed użyciem, ale daja֒ one dodatkowe
mechanizmy, jak również wie֒ ksza֒ elastyczność poslugiwania sie֒ .
CLIPS> (deftemplate osoba
(slot imie (default ?NONE))
(slot wiek (type INTEGER))
(slot plec (type SYMBOL) (allowed-symbols M K) (default ?NONE)))
CLIPS> (assert (osoba (wiek 0)))
[TMPLTRHS1] Slot imie requires a value because of its (default ?NONE) attribute.
CLIPS> (assert (osoba (imie jacus) (wiek 0)))
[TMPLTRHS1] Slot plec requires a value because of its (default ?NONE) attribute.
CLIPS> (assert (osoba (imie jacus) (wiek zero) (plec M)))
[CSTRNCHK1] A literal slot value found in the assert command
does not match the allowed types for slot wiek.
CLIPS> (assert (osoba (imie jacus) (wiek 0) (plec M)))
<Fact-1>
CLIPS> (assert (osoba (imie filip) (wiek 23) (plec M+K)))
[CSTRNCHK1] A literal slot value found in the assert command
does not match the allowed values for slot plec.
CLIPS — wprowadzenie
20
(deffacts jas_przyjaciele
(osoba (imie jas) (wiek 16) (plec M))
(osoba (imie zdzich) (wiek 18) (plec M))
(osoba (imie rychu) (wiek 19) (plec M))
(osoba (imie malgosia) (wiek 17) (plec K))
(koledzy (osoba1 jas) (osoba2 zdzich))
(koledzy (osoba1 jas) (osoba2 rychu))
(koledzy (osoba1 jas) (osoba2 malgosia)))
(deftemplate koledzy
(slot osoba1)
(slot osoba2))
(defrule koledzy-symetria
(koledzy (osoba1 ?o1) (osoba2 ?o2&~?o1))
=>
(assert (koledzy (osoba1 ?o2) (osoba2 ?o1))))
(defrule koledzy-przechodniosc
(koledzy (osoba1 ?o1) (osoba2 ?o2))
(koledzy (osoba1 ?o2) (osoba2 ?o3&~?o1))
=>
(assert (koledzy (osoba1 ?o1) (osoba2 ?o3))))
CLIPS — wprowadzenie
21
CLIPS> (run)
CLIPS (V6.24 06/15/06)
CLIPS> (facts)
CLIPS> (load jas_struct.clp)
f-0
(initial-fact)
Defining deftemplate: osoba
f-1
(osoba (imie jas) (wiek 16) (plec M))
Defining deftemplate: koledzy
f-2
(osoba (imie zdzich) (wiek 18) (plec M))
Defining deffacts: jas_przyjaciele
f-3
(osoba (imie rychu) (wiek 19) (plec M))
Defining defrule: koledzy-symetria +j
f-4
(osoba (imie malgosia) (wiek 17) (plec K))
Defining defrule: koledzy-przechodniosc +j+j
f-5
(koledzy (osoba1 jas) (osoba2 zdzich))
TRUE
f-6
(koledzy (osoba1 jas) (osoba2 rychu))
CLIPS> (reset)
f-7
(koledzy (osoba1 jas) (osoba2 malgosia))
CLIPS> (facts)
f-8
(koledzy (osoba1 malgosia) (osoba2 jas))
f-0
(initial-fact)
f-9
(koledzy (osoba1 malgosia) (osoba2 rychu))
f-1
(osoba (imie jas) (wiek 16) (plec M))
f-10
(koledzy (osoba1 rychu) (osoba2 malgosia))
f-2
(osoba (imie zdzich) (wiek 18) (plec M))
f-11
(koledzy (osoba1 rychu) (osoba2 jas))
f-3
(osoba (imie rychu) (wiek 19) (plec M))
f-12
(koledzy (osoba1 rychu) (osoba2 zdzich))
f-4
(osoba (imie malgosia) (wiek 17) (plec K))
f-13
(koledzy (osoba1 zdzich) (osoba2 rychu))
f-5
(koledzy (osoba1 jas) (osoba2 zdzich))
f-14
(koledzy (osoba1 zdzich) (osoba2 jas))
f-6
(koledzy (osoba1 jas) (osoba2 rychu))
f-15
(koledzy (osoba1 zdzich) (osoba2 malgosia))
f-7
(koledzy (osoba1 jas) (osoba2 malgosia))
f-16
(koledzy (osoba1 malgosia) (osoba2 zdzich))
For a total of 8 facts.
For a total of 17 facts.
CLIPS — wprowadzenie
22
System obiektowy
CLIPS — wprowadzenie
23
Strategia, refrakcja, priorytety
Stategie doste֒ pne w CLIPS’ie (funkcja set-strategy):
• wgla֒b (dopasuj reguly do ostatnio utworzonych faktów) - DOMYŚLNA
• wszerz (dopasuj reguly do najdawniej utworzonych faktów)
• specjalizacji (dopasuj reguly z najwie֒ ksza֒ liczba֒ najbardziej skomplikowanych
warunków)
• przypadkowa
• jeszcze kilka innych
Aktywacja raz odpalona nie be֒ dzie ponownie utworzona, chyba, że fakt, na
którym zostala dopasowana otrzyma nowy indeks (stempel czasowy).
Priorytety regul (salience) daja֒ metode֒ kontroli sekwencyjności wykonywania
regul. Jednak NA OGÓL korzystanie z nich na stanowi bla֒d metodologiczny,
podobny do wykorzystania goto w je֒ zyku proceduralnym.
Nawet jeśli chcemy wprowadzić bardzo zgrubne i tylko pomocnicze
sekwencjonowanie wykonania regul (np. po pola֒czeniu dwóch zestawów regul
dotycza֒cych oddzielnych faz rozwia֒zywania zadania) to lepiej i czyściej jest
zrobić to za pomoca֒ tzw. faktów kontrolnych.
CLIPS — wprowadzenie
24
;;; zwykle zle rozwiazanie
(defrule pierwsza
(declare (salience 2000))
...
)
(defrule druga
(declare (salience 1000))
...
)
;;; lepiej
(defrule pierwsza
...
=>
(assert (lec-druga))
)
(defrule druga
(lec-druga)
...
=>
)
CLIPS — wprowadzenie
25
Przyklady z zestawu
wine.clp: moduly, obliczanie wartosci pewnosci
rpc.clp: strategia random
CLIPS — wprowadzenie
26
Przyklad: prosty uklad logiczny
W poniższym przykladzie przedstawiony jest zestaw instrukcji je֒ zyka CLIPS
tworza֒cy prosty uklad logiczny z dwoma wejściami (SYGNAL), jedna֒ bramka֒
logiczna֒ (OR), i jednym wyjściem (LED). Klauzule ze slowem kluczowym
stanowia֒cym nazwe֒ elementu logicznego określaja֒ typ użytych elementów,
natomiast klauzule ze slowem kluczowym “polaczenie” określaja֒ uklad pola֒czeń.
Pierwszy argument w tych klauzulach podaje element, z którego wyjście
pola֒czone jest z elementem podanym w drugim argumencie. W przypadkach
gdy dany element ma wie֒ cej niż jedno wejście lub wyjście w klauzuli podany jest
również numer wejścia lub wyjścia.
(assert
(assert
(assert
(assert
(assert
(assert
(assert
CLIPS — przyklad
(SYGNAL S-1))
(SYGNAL S-2))
(OR O-1))
(LED L-1))
(polaczenie S-1 O-1 1))
(polaczenie S-2 O-1 2))
(polaczenie O-1 L-1))
27
Przyklad: Uklad z elementem POWIEL
Warto zwrócić uwage֒ na przyje֒ ta֒ konwencje֒ polegaja֒ca֒ na tym, że pola֒czenia
istnieja֒ wyla֒cznie mie֒ dzy pojedynczymi zaciskami elementów. Każde pola֒czenie
biegnie od dokladnie jednego wyjścia jakiegoś elementu do dokladnie jednego
wejścia innego. Nie dopuszczamy zatem możliwości zwierania ze soba֒ wielu
wejść. Aby taka֒ możliwość zapewnić wprowadzamy specjalny element, o nazwie
POWIEL, jednym wejściu i dwóch wyjściach, który pozwala dowolny sygnal
rozmnożyć. Kolejny przyklad przedstawia uklad, w którym jeden sygnal
źródlowy podany jest jednocześnie na oba wejścia bramki XOR.
(assert
(assert
(assert
(assert
(assert
(assert
(assert
(assert
CLIPS — przyklad
(SYGNAL S-1))
(POWIEL P-1))
(BRAMKA-XOR X-1))
(LED L-1))
(polaczenie S-1 P-1))
(polaczenie P-1 1 X-1 1))
(polaczenie P-1 2 X-1 2))
(polaczenie X-1 L-1))
28
Przyklad: Struktura do deklaracji bramek logicznych
(deftemplate BRAMKA
"struktura do reprezentacji bramek logicznych"
(slot typ
(type SYMBOL)
(allowed-symbols NAND AND NOR OR NOT)
(default ?NONE))
(slot nazwa
(type SYMBOL)
(default ?NONE))
(slot liczba-wejsc
(type INTEGER)
(default 2))
(multislot wejscia
(type SYMBOL))
(slot stan-wyjscia
(type SYMBOL)
(allowed-symbols NIEZNANY NISKI WYSOKI)
(default NIEZNANY)))
CLIPS — przyklad
29
Przyklad: Regula obliczajaca
stan bramki
֒
Jak widać, aby przedstawiona regula miala spelniony komplet warunków, w
pamie֒ ci danych musi istnieć bramka NAND z określonymi elementami
podla֒czonymi do jej wejść (to znaczy, nie be֒ dzie dopasowania gdy dla jakiejś
bramki NAND wejścia be֒ da֒ nieznane). Bramki, które sa֒ podla֒czone do wejść
przedmiotowej bramki NAND również musza֒ istnieć w pamie֒ ci danych. Nie jest
istotny ich typ, a nawet nie jest istotne czy ich typ jest znany, ale istotne jest,
że stany ich wyjść musza֒ być określone.
(defrule wyznacz-wyjscie-NAND
(BRAMKA (typ NAND) (nazwa ?n) (wejscia ?e1 ?e2))
(BRAMKA (nazwa ?e1) (stan-wyjscia ?s1 & WYSOKI|NISKI))
(BRAMKA (nazwa ?e2) (stan-wyjscia ?s2 & WYSOKI|NISKI))
=>
(bind ?w (if (and (eq ?s1 WYSOKI) (eq ?s2 WYSOKI))
then NISKI
else WYSOKI))
(printout t Wyznaczony " " stan " " wyjscia " " bramki " " ?n
" " jest " " ?w crlf))
CLIPS — przyklad
30
Przyklad: Fakty strukturalne definiujace
maly uklad
֒
testowy
(BRAMKA
(BRAMKA
(BRAMKA
(BRAMKA
(BRAMKA
(BRAMKA
(BRAMKA
(BRAMKA
(BRAMKA
(BRAMKA
(typ
(typ
(typ
(typ
(typ
(typ
(typ
(typ
(typ
(typ
OR) (nazwa O-1) (stan-wyjscia WYSOKI))
OR) (nazwa O-2) (stan-wyjscia WYSOKI))
OR) (nazwa O-3) (stan-wyjscia NISKI))
OR) (nazwa O-4) (stan-wyjscia NISKI))
OR) (nazwa O-5) (stan-wyjscia NIEZNANY))
NAND) (nazwa N-1) (wejscia O-1 O-2))
NAND) (nazwa N-2) (wejscia O-2 O-3))
NAND) (nazwa N-3) (wejscia O-4 O-1))
NAND) (nazwa N-4) (wejscia O-3 O-4))
NAND) (nazwa N-5) (wejscia O-4 O-5))
Poza bramkami OR niezbe֒ dnymi w tym przykladzie dla dostarczenia sygnalów
wejściowych dla badanej bramki NAND, których sygnaly wyjściowe sa֒ znane
(WYSOKI lub NISKI) w przykladzie wprowadzono również dodatkowa֒ bramke֒
N-5 typu NAND, która jest zasilana w taki sposób, że jeden z sygnalów na jej
wejściu jest NIEZNANY.
CLIPS — przyklad
31
Przyklad: Wyniki obliczenia sygnalów wyjściowych
bramek
sierra-41> clips
CLIPS (V6.0 05/12/93)
CLIPS> (load "regula.clp")
Redefining deftemplate: BRAMKA
Defining defrule: wyznacz-wyjscie-NAND +j+j+j
TRUE
CLIPS> (load-facts "bramki.clp")
TRUE
CLIPS> (run)
Wyznaczony stan wyjscia bramki N-4 jest WYSOKI
Wyznaczony stan wyjscia bramki N-3 jest WYSOKI
Wyznaczony stan wyjscia bramki N-2 jest WYSOKI
Wyznaczony stan wyjscia bramki N-1 jest NISKI
CLIPS>
CLIPS — przyklad
32
Przyklad: Regula wyznaczajaca
stan bramki w ukladzie
֒
Wcześniejsza֒ regule֒ można w prosty sposób rozszerzyć w taki sposób, aby
obliczony stan wyjściowy bramki logicznej byl wpisywany do ukladu, zamiast być
jedynie wyświetlany na ekranie terminala. Pozwoli to z kolei obliczyć stany
wyjściowe innych bramek, zasilanych z danej, i w efekcie obliczyć wartości
wszystkich wyjść ukladu (zakladaja֒c, że nie zawiera on pe֒ tli).
(defrule wyznacz-wyjscie-NAND
?nand <- (BRAMKA (typ NAND) (nazwa ?n) (wejscia ?e1 ?e2))
(BRAMKA (nazwa ?e1) (stan-wyjscia ?s1 & WYSOKI|NISKI))
(BRAMKA (nazwa ?e2) (stan-wyjscia ?s2 & WYSOKI|NISKI))
=>
(bind ?w (if (and (eq ?s1 WYSOKI) (eq ?s2 WYSOKI))
then NISKI
else WYSOKI))
(modify ?nand (stan-wyjscia ?w)))
CLIPS — przyklad
33
Przyklad: Hierarchia klas do określania elementów ukladu
(defclass ELEMENT
(is-a USER)
(slot ID# (create-accessor write)))
(defclass BEZ-WYJSC
(is-a USER)
(slot liczba-wyjsc (access read-only)
(default 0)
(create-accessor read)))
(defmessage-handler BEZ-WYJSC oblicz-wyjscie ())
(defclass JEDNO-WYJSCIE
(is-a BEZ-WYJSC)
(slot liczba-wyjsc (access read-only)
(default 1)
(create-accessor read))
(slot wyjscie-1 (default NIEOKRESL) (create-accessor write))
(slot wyjscie-1-zlacze (default ZIEMIA) (create-accessor write))
(slot wyjscie-1-zacisk (default 1) (create-accessor write)))
CLIPS — przyklad
34
(defmessage-handler JEDNO-WYJSCIE put-wyjscie-1 after (?value)
(send ?self:wyjscie-1-zlacze
(sym-cat put-wejscie- ?self:wyjscie-1-zacisk)
?value))
(defclass DWA-WYJSCIA
(is-a JEDNO-WYJSCIE)
(slot liczba-wyjsc (access read-only)
(default 2)
(create-accessor read))
(slot wyjscie-2 (default NIEOKRESL) (create-accessor write))
(slot wyjscie-2-zlacze (default ZIEMIA) (create-accessor write))
(slot wyjscie-2-zacisk (default 1) (create-accessor write)))
(defmessage-handler DWA-WYJSCIA put-wyjscie-1 after (?value)
(send ?self:wyjscie-2-zlacze
(sym-cat put-wejscie- ?self:wyjscie-2-zacisk)
?value))
(defclass BEZ-WEJSC
(is-a USER)
(slot liczba-wejsc (access read-only)
(default 0)
(create-accessor read)))
CLIPS — przyklad
35
(defclass JEDNO-WEJSCIE
(is-a BEZ-WEJSC)
(slot liczba-wejsc (access read-only)
(default 1)
(create-accessor read))
(slot wejscie-1 (default NIEOKRESL)
(visibility public)
(create-accessor read-write))
(slot wejscie-1-zlacze (default ZIEMIA) (create-accessor write))
(slot wejscie-1-zacisk (default 1) (create-accessor write)))
(defmessage-handler JEDNO-WEJSCIE put-wejscie-1 after (?value)
(send ?self oblicz-wyjscie))
(defclass DWA-WEJSCIA
(is-a JEDNO-WEJSCIE)
(slot liczba-wejsc (access read-only)
(default 2)
(create-accessor read))
(slot wejscie-2 (default NIEOKRESL)
(visibility public)
(create-accessor write))
(slot wejscie-2-zlacze (default ZIEMIA) (create-accessor write))
CLIPS — przyklad
36
(slot wejscie-2-zacisk (default 1) (create-accessor write)))
(defmessage-handler DWA-WEJSCIA put-wejscie-2 after (?value)
(send ?self oblicz-wyjscie))
(defclass SYGNAL
(is-a BEZ-WEJSC JEDNO-WYJSCIE ELEMENT)
(role concrete)
(slot wyjscie-1 (default NIEOKRESL) (create-accessor write)))
(defclass SINK
(is-a JEDNO-WEJSCIE BEZ-WYJSC ELEMENT)
(role concrete)
(slot wejscie-1 (default NIEOKRESL) (create-accessor read-write)))
CLIPS — przyklad
37
Przyklad: Klasy określajace
elementy logiczne
֒
(defclass BRAMKA-NOT
(is-a JEDNO-WEJSCIE JEDNO-WYJSCIE ELEMENT)
(role concrete))
(deffunction not# (?x) (- 1 ?x))
(defmessage-handler BRAMKA-NOT oblicz-wyjscie ()
(if (integerp ?self:wejscie-1) then
(send ?self put-wyjscie-1 (not# ?self:wejscie-1))))
(defclass BRAMKA-AND
(is-a DWA-WEJSCIA JEDNO-WYJSCIE ELEMENT)
(role concrete))
(deffunction and# (?x ?y)
(if (and (!= ?x 0) (!= ?y 0)) then 1 else 0))
(defmessage-handler BRAMKA-AND oblicz-wyjscie ()
(if (and (integerp ?self:wejscie-1)
(integerp ?self:wejscie-2)) then
(send ?self put-wyjscie-1 (and# ?self:wejscie-1
?self:wejscie-2))))
CLIPS — przyklad
38
(defclass BRAMKA-OR
(is-a DWA-WEJSCIA JEDNO-WYJSCIE ELEMENT)
(role concrete))
(deffunction or# (?x ?y)
(if (or (!= ?x 0) (!= ?y 0)) then 1 else 0))
(defmessage-handler BRAMKA-OR oblicz-wyjscie ()
(if (and (integerp ?self:wejscie-1)
(integerp ?self:wejscie-2)) then
(send ?self put-wyjscie-1
(or# ?self:wejscie-1 ?self:wejscie-2))))
(defclass BRAMKA-NAND
(is-a DWA-WEJSCIA JEDNO-WYJSCIE ELEMENT)
(role concrete))
(deffunction nand# (?x ?y)
(if (not (and (!= ?x 0) (!= ?y 0))) then 1 else 0))
(defmessage-handler BRAMKA-NAND oblicz-wyjscie ()
(if (and (integerp ?self:wejscie-1)
(integerp ?self:wejscie-2)) then
CLIPS — przyklad
39
(send ?self put-wyjscie-1
(nand# ?self:wejscie-1 ?self:wejscie-2))))
(defclass BRAMKA-XOR
(is-a DWA-WEJSCIA JEDNO-WYJSCIE ELEMENT)
(role concrete))
(deffunction xor# (?x ?y)
(if (or (and (= ?x 1) (= ?y 0))
(and (= ?x 0) (= ?y 1))) then 1 else 0))
(defmessage-handler BRAMKA-XOR oblicz-wyjscie ()
(if (and (integerp ?self:wejscie-1)
(integerp ?self:wejscie-2)) then
(send ?self put-wyjscie-1
(xor# ?self:wejscie-1 ?self:wejscie-2))))
(defclass POWIEL
(is-a JEDNO-WEJSCIE DWA-WYJSCIA ELEMENT)
(role concrete))
(defmessage-handler POWIEL oblicz-wyjscie ()
(if (integerp ?self:wejscie-1) then
(send ?self put-wyjscie-1 ?self:wejscie-1)
CLIPS — przyklad
40
(send ?self put-wyjscie-2 ?self:wejscie-1)))
(defclass LED
(is-a JEDNO-WEJSCIE BEZ-WYJSC ELEMENT)
(role concrete))
(deffunction LED-odpowiedz ()
(bind ?odpowiedz (create$))
(do-for-all-instances ((?led LED)) TRUE
(bind ?odpowiedz (create$ ?odpowiedz
(send ?led get-wejscie-1))))
?odpowiedz)
CLIPS — przyklad
41
Przyklad: Funkcja wirtualna polaczenie
(defgeneric polaczenie)
(defmethod polaczenie ((?out JEDNO-WYJSCIE) (?in JEDNO-WEJSCIE))
(send ?out put-wyjscie-1-zlacze ?in)
(send ?out put-wyjscie-1-zacisk 1)
(send ?in put-wejscie-1-zlacze ?out)
(send ?in put-wejscie-1-zacisk 1))
(defmethod polaczenie ((?out JEDNO-WYJSCIE)
(?in DWA-WEJSCIA) (?in-pin INTEGER))
(send ?out put-wyjscie-1-zlacze ?in)
(send ?out put-wyjscie-1-zacisk ?in-pin)
(send ?in (sym-cat put-wejscie- ?in-pin -zlacze) ?out)
(send ?in (sym-cat put-wejscie- ?in-pin -zacisk) 1))
(defmethod polaczenie ((?out DWA-WYJSCIA) (?out-pin INTEGER)
(?in JEDNO-WEJSCIE))
(send ?out (sym-cat put-wyjscie- ?out-pin -zlacze) ?in)
(send ?out (sym-cat put-wyjscie- ?out-pin -zacisk) 1)
(send ?in put-wejscie-1-zlacze ?out)
(send ?in put-wejscie-1-zacisk ?out-pin))
CLIPS — przyklad
42
(defmethod polaczenie ((?out DWA-WYJSCIA) (?out-pin INTEGER)
(?in DWA-WEJSCIA) (?in-pin INTEGER))
(send ?out (sym-cat put-wyjscie- ?out-pin -zlacze) ?in)
(send ?out (sym-cat put-wyjscie- ?out-pin -zacisk) ?in-pin)
(send ?in (sym-cat put-wejscie- ?in-pin -zlacze) ?out)
(send ?in (sym-cat put-wejscie- ?in-pin -zacisk) ?out-pin))
;;; Deklaracja funkcji polacz-uklad niezbednej do uruchomienia
;;; systemu produkcji.
(deffunction polacz-uklad ())
CLIPS — przyklad
43
Przyklad: Pomocnicze zmienne globalne oraz regula
startowa
(defglobal ?*kod-gray* = (create$)
?*sygnaly* = (create$)
?*przebiegi-petli* = 0)
(defrule start
=>
(polacz-uklad)
(bind ?*sygnaly* (find-all-instances ((?x SYGNAL)) TRUE))
(do-for-all-instances ((?x SYGNAL)) TRUE
(bind ?*kod-gray* (create$ ?*kod-gray* 0)))
(bind ?*przebiegi-petli* (round (** 2 (length ?*sygnaly*))))
(assert (przebieg-petli 0)))
CLIPS — przyklad
44
Przyklad: Reguly do obliczania odpowiedzi ukladu
(defrule wylicz-pierwszy-raz
?f <- (przebieg-petli 0)
=>
(do-for-all-instances ((?source SYGNAL))
TRUE
(send ?source put-wyjscie-1 0))
(assert (result ?*kod-gray* =(str-implode (LED-odpowiedz))))
(retract ?f)
(assert (przebieg-petli 1)))
(deffunction zmien-bit (?x)
(bind ?i 1)
(while (and (evenp ?x) (!= ?x 0)) do
(bind ?x (div ?x 2))
(bind ?i (+ ?i 1)))
?i)
(defrule wylicz-nastepny-raz
?f <- (przebieg-petli ?n&~0&:(< ?n ?*przebiegi-petli*))
=>
(bind ?pos (zmien-bit ?n))
CLIPS — przyklad
45
(bind ?nv (- 1 (nth ?pos ?*kod-gray*)))
(bind ?*kod-gray* (replace$ ?*kod-gray* ?pos ?pos ?nv))
(send (nth ?pos ?*sygnaly*) put-wyjscie-1 ?nv)
(assert (result ?*kod-gray* =(str-implode (LED-odpowiedz))))
(retract ?f)
(assert (przebieg-petli =(+ ?n 1))))
CLIPS — przyklad
46
Przyklad: Reguly do formatowania tabelki przejść ukladu
(defrule polacz-odpowiedzi
(declare (salience 10))
?f1 <- (result $?b ?x $?e ?odpowiedz)
?f2 <- (result $?b ~?x $?e ?odpowiedz)
=>
(retract ?f1 ?f2)
(assert (result $?b * $?e ?odpowiedz)))
(defrule wyswietl-naglowek
(declare (salience -10))
=>
(assert (wyswietl-wyniki))
(do-for-all-instances
((?x SYGNAL)) TRUE (format t " %3s " (sym-cat ?x)))
(printout t " | ")
(do-for-all-instances
((?x LED)) TRUE (format t " %3s " (sym-cat ?x)))
(format t "%n")
(do-for-all-instances ((?x SYGNAL)) TRUE (printout t "-----"))
(printout t "-+-")
(do-for-all-instances ((?x LED)) TRUE (printout t "-----"))
CLIPS — przyklad
47
(format t "%n"))
(defrule wyswietl-wyniki
(wyswietl-wyniki)
?f <- (result $?wejscie ?odpowiedz)
(not (result $?wejscie-2
?odpowiedz-2&:(< (str-compare ?odpowiedz-2
?odpowiedz)
0)))
=>
(retract ?f)
(while (neq ?wejscie (create$)) do
(printout t " " (nth 1 ?wejscie) " ")
(bind ?wejscie (rest$ ?wejscie)))
(printout t " | ")
(bind ?odpowiedz (str-explode ?odpowiedz))
(while (neq ?odpowiedz (create$)) do
(printout t " " (nth 1 ?odpowiedz) " ")
(bind ?odpowiedz (rest$ ?odpowiedz)))
(printout t crlf))
CLIPS — przyklad
48
Przyklad: Deklaracja elementów przykladowego ukladu
(definstances przyklad
(S-1 of SYGNAL)
(S-2 of SYGNAL)
(S-3 of SYGNAL)
(S-4 of SYGNAL)
(S-5 of SYGNAL)
(S-6 of SYGNAL)
(P-1 of POWIEL)
(P-2 of POWIEL)
(P-3 of POWIEL)
(P-4 of POWIEL)
(N-1 of BRAMKA-NOT)
(N-2 of BRAMKA-NOT)
(N-3 of BRAMKA-NOT)
(O-1 of BRAMKA-OR)
(O-2 of BRAMKA-OR)
(X-1 of BRAMKA-XOR)
(X-2 of BRAMKA-XOR)
(A-1 of BRAMKA-AND)
(D-1 of BRAMKA-NAND)
(D-2 of BRAMKA-NAND)
CLIPS — przyklad
49
(L-1 of LED)
(L-2 of LED)
(L-3 of LED))
CLIPS — przyklad
50
Przyklad: Definicja polaczeń
przykladowego ukladu
֒
(deffunction polacz-uklad ()
(polaczenie [S-1] [P-1])
(polaczenie [S-2] [P-2])
(polaczenie [S-3] [P-3])
(polaczenie [S-4] [A-1] 2)
(polaczenie [S-5] [D-1] 2)
(polaczenie [S-6] [O-2] 2)
(polaczenie [P-1] 1 [O-1] 1)
(polaczenie [P-1] 2 [N-1])
(polaczenie [P-2] 1 [N-2])
(polaczenie [P-2] 2 [A-1] 1)
(polaczenie [P-3] 1 [X-1] 2)
(polaczenie [P-3] 2 [D-1] 1)
(polaczenie [N-1] [X-1] 1)
(polaczenie [N-2] [O-1] 2)
(polaczenie [O-1] [X-2] 1)
(polaczenie [X-1] [X-2] 2)
(polaczenie [A-1] [D-2] 1)
(polaczenie [D-1] [O-2] 1)
(polaczenie [X-2] [P-4])
(polaczenie [O-2] [D-2] 2)
CLIPS — przyklad
51
(polaczenie
(polaczenie
(polaczenie
(polaczenie
CLIPS — przyklad
[P-4]
[P-4]
[D-2]
[N-3]
1 [N-3])
2 [L-2])
[L-3])
[L-1]))
52
Przyklad: Wyniki dzialania programu
CLIPS> (load "przyklad.clp")
Defining definstances: przyklad
Redefining deffunction: polacz-uklad
TRUE
CLIPS> (reset)
CLIPS> (run)
S-1 S-2 S-3 S-4 S-5 S-6 | L-1 L-2 L-3
-------------------------------+---------------*
1
0
1
*
*
|
0
1
0
1
0
0
1
*
*
|
0
1
1
0
0
1
*
*
*
|
0
1
1
0
1
0
0
*
*
|
0
1
1
1
*
0
0
*
*
|
0
1
1
*
1
1
1
0
0
|
1
0
0
*
1
1
1
*
1
|
1
0
0
*
1
1
0
0
0
|
1
0
1
*
1
1
*
1
0
|
1
0
1
1
0
1
*
*
*
|
1
0
1
*
1
1
0
*
1
|
1
0
1
0
0
0
*
*
*
|
1
0
1
CLIPS>
CLIPS — przyklad
53
Proces tworzenia systemów doradczych
• reprezentacja wiedzy
= identyfikacja, konceptualizacja, formalizacja, implementacja
• pozyskiwanie wiedzy
= przeksztalcenie wiedzy z formy w jakiej jest doste֒ pna na przyje֒ ta֒ forme֒
reprezentacji wiedzy w systemie
Tworzenie regulowych systemów doradczych
54
Waskie
gardlo procesu pozyskiwania wiedzy
֒
• wiedza jest pozyskiwana w procesie interakcji mie֒ dzy ludźmi
• eksperci dostarczaja֒ wiedze֒ niepelna֒, niekoniecznie poprawna֒
• eksperci nie potrafia֒ w pelni wyrazić swej wiedzy
• czasami eksperci sa֒ trudno doste֒ pni, a moga֒ także przyjmować stanowisko
nieche֒ tne
• kompilacja wiedzy pochodza֒cej z różnych źródel jest trudna a czasami
niemożliwa ze wzgle֒ du na różne systemy pojeć
֒ , poziomy wyrażenia,
przyjmowane a priori zależenia
Tworzenie regulowych systemów doradczych
55
Problem generacji uzasadnień
• wyjaśnienia skierowane do: użytkowników (w tym ksztalcenie), ekspertów,
twórców systemu
• niezbe֒ dne do: zrozumienia rozwia֒zania, wzmocnienia zaufania odbiorcy do
wyników uzyskanych przez system, debugowania bazy wiedzy, w celach
edukacyjnych, w celach dokumentacyjnych
Tworzenie regulowych systemów doradczych
56
Proces wnioskowania
• forward chaining: wycia֒gaj wnioski zaraz jak tylko jest to możliwe
Tak dzialaja֒ niektóre systemy produkcji, również CLIPS.
• backward chaining: najpierw sprawdzaj czy cel zostal osia֒gnie֒ ty, a jeśli nie to
czego brak dla osia֒gnie֒ cia celu, i naste֒ pnie postaw to czego brakuje jako podcel
tymczasowy
Tworzenie regulowych systemów doradczych
57
Schemat wnioskowania systemów produkcji
W trakcie pracy system produkcji wykonuje wiele kroków zwia֒zanych z
odpalaniem konkretnych regul. Kroki te generuja֒ dodatkowe informacje
rozszerzaja֒ce pocza֒tkowa֒ baze֒ danych o problemie aż do momentu, w którym
zawiera ona również opis rozwia֒zania. Kroki te można zgrupować w trzy fazy.
Abstrakcja danych
dopasowanie
heurystyczne
-
Abstrakcja rozwia֒zania
6
uogólnienie
konkretyzacja
?
Dane
Tworzenie regulowych systemów doradczych
Rozwia֒zanie
58
Pierwsza faza polega na uogólnianiu, tzn. abstrahowania (pominie֒ ciu) pewnych
szczególów i wyodre֒ bnieniu kluczowych cech problemu, aby zaliczyć go do
określonej klasy. Druga faza — heurystyczna — sugeruje ogólne formy
rozwia֒zań dla ogólnie sformulowanych klas problemów. Trzecia faza jest faza֒
konkretyzacji, gdzie ogólnie sformulowane rozwia֒zanie jest uszczególowione i
dostosowane do konkretnego problemu.
W fazie pierwszej i trzeciej rozumowanie jest zwykle systematyczne, gdzie reguly
rza֒dza֒ce kolejnymi krokami maja֒ zwykle solidne uzasadnienie i wiedza fachowa
z danej dziedziny dobrze je określa. W fazie drugiej kroki maja֒ charakter
wie֒ kszych przeskoków, pomijaja֒c wnioski pośrednie, których sformulowanie
może być klopotliwe.
Schemat ten zostal w sposób systematyczny zbadany i nazywany klasyfikacja֒
heurystyczna֒. Określenie klasyfikacja odzwierciedla fakt, że musi istnieć
określony zbiór typowych schematów rozwia֒zań i musza֒ być znane bezpośrednie
powia֒zania pomie֒ dzy typowymi schematami problemu a schematami rozwia֒zań.
W efekcie systemy te moga֒ operować jedynie na malej liczbie schematów
rozwia֒zań, co najwyżej sparametryzowanych. Ich rola֒ jest jedynie wybór
wlaściwego rozwia֒zania.
Tworzenie regulowych systemów doradczych
59