POLITECHNIKA KOSZALIŃSKA
MICHAŁ BIAŁKO
KATARZYNA MUSIAŁ
PROGRAMOWANIE W JĘZYKU CLIPS 6.0
PODRĘCZNIK DO ĆWICZEŃ LABORATORYJNYCH
Z PRZEDMIOTU "SYSTEMY EKSPERTOWE'
KOSZALIN 2001
Spis treści
CZĘŚĆ 1. PROGRAMOWANIE REGUŁOWE.................................. 4
1. WPROWADZENIE.........................................................................................................4
1.1. Wiadomości ogólne o systemach ekspertowych...............................................4
1.2. Ogólny opis CLIPS-a......................................................................................4
2. FAKTY...............:............................................................................................................11
2.1. Potwierdzanie (asercja) faktów.........................................................................11
2.2. Usuwanie faktów...............................................................................................12
3. REGUŁY.......................................................................................................................... 12
3.1. Definiowanie reguł........................................................................................... 12
3.2. Priorytet wykonywania reguł.............................................................................15
4. ZMIENNE...............,...:........................,............................................................................16
4.1. Zmienne jednopolowe....................................................................................... 16
4.2. Zmienne wielopolowe.:......................................................................................17
4.3. Funkcje obsługujące zmienne wielopolowe.......................................................17
5. OPERACJE MATEMATYCZNE.................................................................................... 20
5.1. Elementarne operacje matematyczne.................................................................20
5.2. Funkcje trygonometryczne.................................................................................21
5.3. Inne funkcje matematyczne................................................................................21
6. KILKA POŻYTECZNYCH FUNKCJI I KOMEND....................................................... 22
6.1. Funkcje (read) i (readline)..................................................................................23
6.2. Komenda (format t...)..........................................................................................23
6.3. Funkcja (test...).................................................................................................... 24
6.4. Funkcje (gensym) i (gensym*)............................................................................25
6.5. Funkcje logiczne AND, GR i NOT po lewej stronie reguły... ……..………..... 27
7. FUNKCJE DEFINIOWANE PRZEZ UŻYTKOWNIKA................................................ 27
8. OPERACJE NA ŁAŃCUCHACH.....................................................................................29
9. ZMIENNE GLOBALNE................................................................................................... 31
10. STRUKTURY I FUNKCJE PROCEDURALNE........................................................... 32
10.1. Struktura (if...then...else...)............................................................................... 32
10.2. Struktura (while ...)........................................................................................... 33
10.3. Funkcja (loop-for-count...).................................................................................33
10.4. Funkcja (progn ...)............................................................................................. 34
10.5. Funkcja (progn$ ...)........................................................................................... 34
10.6. Funkcja (switch ...).............................................................................................35
11.SZABLONY.......................................................................................................................36
11.1. Tworzenie szablonów.........................................................................................36
11.2. Szablon jako wzór po lewej stronie reguły....................................................... 38
12. OGRANICZENIA WARUNKÓW PO LEWEJ STRONIE REGUŁY…………….........39
13. ŚLEDZENIE I KOREKTA PROGRAMU (DEBUGGING)............................................42
13.1. Śledzenie wykonywania programu....................................................................42
13.2. Krokowe wykonywanie programu.................................................................... 43
13.3. Wstawianie punktów przerwań...........................................................................44
13.4. Kontrola dopasowania faktów do warunków w regułach...................................44
14. DYNAMICZNE ZMIANY PROGRAMU PODCZAS JEGO
WYKONYWANIA........................................................................................................... 45
14.1. Zmiana kolejności uaktywniania reguł z użyciem zmiennych globalnych................................................................................................................... 45
14.2. Tworzenie nowych reguł w trakcie wykonywania programu............................ 46
15. STRATEGIE KOLEJNOŚCI WYKONYWANIA REGUŁ............................................47
CZĘŚĆ 2. PROGRAMOWANIE OBIEKTOWE................................................48
16. WPROWADZENIE DO PROGRAMOWANIA OBIEKTOWEGO …………………..48
17. KLASY I INSTANCJE.....................................................................................................49
17.1. Tworzenie klas użytkownika............................................................................. 51
17.2. Funkcje orzekające (predykatowe) dotyczące Was………………................... 52
17.3. Usuwanie klas.................................................................................................... 53
18. INSTANCJE..................................................................................................................... 53
18.1. Tworzenie instancji.............................................................................................53
18.2. Ładowanie instancji z pliku i ich zapis do pliku................................................. 56
18.3. Wstawianie i pobieranie wartości slotów........................................................... 57
18.4. Funkcje orzekające (predykatowe) dotyczące instancji...................................... 58
18.5. Instancja jako warunek po lewej stronie reguły................................................. 59
19. FASETY.,..........................................................................................................................64
19.1. Opis slotu za pomocą faset............................................................................... 64
19.2. Sloty jedno- i wielopolowe.............................................................................. 66
19.3. Wstawianie do slotu wartości domyślnej (faseta (default...))………………... 67
19.4. Dziedziczenie slotu (faseta (propagation ..))………………............................ 67
19.5. Dostęp do wartości slotu (faseta (access ...))………………............................ 67
19.6. Miejsce przechowywania wartości slotu (faseta (storage ...)).......................... 68
19.7. Widoczność wartości slotu (faseta (visibility..))…………………....................69
19.8. Tworzenie komunikatów do wstawiania i pobierania wartości slotu (faseta (create-accessor ..))………………………................................................................ 69
20. KOMUNIKATY..............................................................................................................70
20.1. Definiowanie komunikatów użytkownika....................................................... 70
20.2. Typy komunikatów...........................................................................................71
20.3. Więcej informacji o zmiennej ?self..................................................................75
20.4. Demony...........................................................................................................75
20.5. Kolejność wywoływania komunikatów.......................................................... 77
21. PROGRAMOWANIE Z UŻYCIEM OBIEKTÓW I
KOMUNIKATÓW.............................................................................................................. 78
21.1. Funkcje grupujące............................................................................................78
21.2. Obliczanie wartości slotów.............................................................................79
22. OBIEKTOWA BAZA DANYCH...................................................................................80
23. FUNKCJE SPRAWDZAJĄCE WARUNKI....................................................................86
24. PRZECIĄŻANIE FUNKCJI I DEFINIOWANIE METOD............................................ 90
24.1. Definiowanie metod.......................................................................................... 91
24.2. Priorytet metod................................................................................................ 92
24.3. Zastosowanie metod do wykonywania obliczeń na liczbach zespolonych…. 93
24.4. Metody z argumentami wielopolowymi............................................................96
DODATEK A. OPIS MENU................................................................................................. 97
DODATEK B. OMÓWIENIE NAJCZĘŚCIEJ POPEŁNIANYCH BŁĘDÓW…………..102
B.l. Błędy wykrywane podczas kompilacji................................................................102
B.2. Błędy wykrywane po uruchomieniu programu..................................................106
DODATEK C. SPIS POLECEŃ I FUNKCJI CLIPS-A 6.0..................................................109
CZĘSC PIERWSZA PROGRAMOWANIE REGUŁOWE
1. WPROWADZENIE
1.1 Wiadomości ogólne o systemach ekspertowych
CLIPS jest specjalizowanym językiem programowania, przeznaczonym do tworzenia systemów ekspertowych. Został on opracowany przez NASA/Johnson Space Center i upowszechniony w roku 1988 (wersja 3.2).
System ekspertowy jest "inteligentnym" programem komputerowym tak skonstruowanym, aby mógł naśladować postępowanie człowieka-eksperta w pewnej dziedzinie wiedzy przy rozwiązywaniu problemów z tej dziedziny. System taki musi więc zawierać wiedzę eksperta zakodowaną w postaci reguł typu: JEŻELI ... TO ... oraz procedurę wnioskowania. Systemy ekspertowe stosuje się zwłaszcza w dziedzinach, które nie są w jednoznaczny sposób sformalizowane, a więc gdy nie istnieje algorytm rozwiązania postawionego problemu. Do rozwiązania problemu niezbędna jest wtedy wiedza i doświadczenie eksperta. Właśnie owo doświadczenie, zdobyte w trakcie wieloletniej działalności eksperta, pozwala na uzyskiwanie wysokiej jakości rozwiązań, w stosunkowo krótkim czasie, dzięki stosowaniu rozumowania heurystycznego. Rozumowanie heurystyczne polega na wykorzystywaniu intuicji, zdobytych doświadczeń, "skrótów myślowych" itp., co stanowi uzupełnienie sformalizowanej wiedzy z danej dziedziny.
Typowe zastosowania systemów ekspertowych to:
• klasyfikacja - przyporządkowanie obiektów do danych grup ze względu na ich właściwości,
• interpretacja - opis sytuacji wnioskowany np. z pomiarów przy użyciu dużej liczby czujników, przyrządów pomiarowych lub innych danych,
...
MariuszR