Różnice między wybraną wersją a wersją aktualną.
| Both sides previous revision Poprzednia wersja Nowa wersja | Poprzednia wersja | ||
|
pl:dydaktyka:piw:2010:systemy_ekspertowe:hekate_iii [2010/04/26 10:48] esimon |
pl:dydaktyka:piw:2010:systemy_ekspertowe:hekate_iii [2019/06/27 15:50] (aktualna) |
||
|---|---|---|---|
| Linia 1: | Linia 1: | ||
| - | ====== Język HMR ====== | + | ====== HMR language ====== |
| - | Język HMR został stworzony w celu tekstowej reprezentacji diagramów XTT^2. Jego składnia została zaprojektowana z uwzględnieniem języka w którym implementowany był HeaRT; innymi słowy, składnia języka HMR jest podzbiorem podstawowej składni Prologu, wzbogaconym o kilka dodatkowych operatorów, odzwierciedlających relacje zachodzące pomiędzy elementami XTT. | + | |
| - | Plik HMR składa się z następujących sekcji: | + | The HMR language has been designed to textual human and machine redable representation of XTT2 models. |
| - | * Definicje typów (predykat //xtype//), | + | The syntax of the HMR is a subset of Prolog syntax where a number of operators have been defined. |
| - | * Opcjonalne definicje grup typów (predykat //xtpgr//), | + | |
| - | * Definicje atrybutów (predykat //xattr//), | + | |
| - | * Opcjonalne definicje grup atrybutów (predykat //xatgr//), | + | |
| - | * Definicje schematów (tabel) (predykat //xschm//), | + | |
| - | * Definicje reguł (predykat //xrule//), | + | |
| - | * Opcjonalne definicje stanów (predykat //xstat//). | + | |
| - | * Opcjonalne definicje callbacków (predykat //xcall//) | + | |
| - | Każdy z wymienionych predykatów (za wyjątkiem //xschm// i //xrule//) strukturalnie odpowiada liście w języku Prolog, której elementy opisują własności obiektu XTT reprezentowanego przez dany predykat. | + | Each HMR file consists of the following parts: |
| + | * [requied] Types definitions (predicate //xtype//), | ||
| + | * [optional] Types groups definitions (predicate //xtpgr//), | ||
| + | * [requied] Attributes definitions (predicate //xattr//), | ||
| + | * [optional] Attributes groups definitions (predicate //xatgr//), | ||
| + | * [requied]Definicje schematów (tabel) (predicate //xschm//), | ||
| + | * [requied] Rules definitions (predicate //xrule//), | ||
| + | * [optional] States definitions (predicate //xstat//). | ||
| + | * [optional] Callbacks definitions (predicate //xcall//) | ||
| + | Each of predicates (besides //xschm// and //xrule//) is a Prolog list, which defines the properities of a XTT object. | ||
| - | Na przykład definicja typu //weekdays// i atrybutu //day// wygląda tak jak poniżej: | + | In example, the definitions of type //weekdays// and an attribute //day// is as follows: |
| <code> | <code> | ||
| xtype [name: weekdays, | xtype [name: weekdays, | ||
| Linia 41: | Linia 42: | ||
| </code> | </code> | ||
| - | === Ćwiczenie === | + | === Exercise === |
| - | Porównaj plik HMR z modelem XTT2: | + | Compare the HMR file with XTT model: |
| - | * {{:pl:dydaktyka:piw:2010:systemy_ekspertowe:thermostat-clb-pl.pl|}} | + | * HMR file: |
| - | * Termostat w XTT: | + | {{:pl:dydaktyka:piw:2010:systemy_ekspertowe:thermostat-clb-pl.pl|}} |
| + | * XTT file: | ||
| + | {{:pl:dydaktyka:piw:2010:systemy_ekspertowe:thermostat-xtt.png|}} | ||
| - | ====== Callbacks w HMR ====== | + | ====== Callbacks in HMR ====== |
| - | Callbacki to funkcje wywoływane podczas przetwarzania tabel XTT w celu pobrania danych spoza systemu lub do zaprezentowania tych danych. Przykładową funkcję callbacków przedstawia rysunek poniżej. W systemie symulującym zachowanie bankomatu callbacki będą wykorzystywane do wyświetlenia okna pobierającego PIN i do wyświetlania komunikatów dla użytkownika. | + | Callbacks are the functions that are executed during the XTT tables evaluation in order to get a value or to present a value. |
| + | The example of the callbacks execution results are showed in the picture below. | ||
| + | In the cashpoint system, the callbacks are used for calling a enter PIN dialog as well as for displaying messages to the user. | ||
| {{:pl:dydaktyka:piw:2010:systemy_ekspertowe:callbacks.png|}} | {{:pl:dydaktyka:piw:2010:systemy_ekspertowe:callbacks.png|}} | ||
| + | There are two types of callbacks: | ||
| + | * //in// - are executed before (or during) inference process in order to get attributes value. | ||
| + | * //out// - are executed for values of attributes presentation, when the inference process is finished. | ||
| + | The type of a callback is determined by value of the attribute //comm// property. | ||
| - | Wyróżnia się dwa typy callbacków: | + | HMR syntax provides a **callback** property of the XTT attribute that indicates which callback function should be called. |
| - | * //in// - wywołują się one przed rozpoczęciem (lub w trakcie działania) wnioskowania w celu pobrania wartości atrybutów wymaganych do przeprowadzenia inferencji. | + | The property has a list structure, where the first element is the name of the callback function and the second is a list of parameters. |
| - | * //out// - wywołują się już po zakończeniu wnioskowania w celu prezentacji wartości atrybutów. | + | |
| - | + | ||
| - | Typ callbacku zależy od wartości elementu //comm// w definicji atrybutu w języku HMR. | + | |
| - | + | ||
| - | Elementem określającym jaki callback ma być wywołany dla danego atrybutu, jest pole **callback**. Jets ono postaci listy, której pierwszy element jest nazwą callbaku do wywołania a drugi jest listą parametrów jakie chcemy przekazać callbackowi: | + | |
| <code> | <code> | ||
| - | comm: in, | + | xattr [name: day, |
| - | callback: [ask_symbolic_GUI,[day]] | + | abbrev: day, |
| + | class: simple, | ||
| + | type: day, | ||
| + | comm: in, | ||
| + | callback: [ask_console,[day]] | ||
| + | ]. | ||
| </code> | </code> | ||
| - | Powyższy kod oznacza, że dla atrybutu w którym się on pojawi będzie wywołany callback typu //in// o nazwie //ask_symbolic_GUI//, pobierający jako parametr jedną wartość //day//. | + | The above example defines an attribute //day//. |
| - | + | The value of the property //comm// of this attribute is **in** what defines the type of the callback to be **in**. | |
| - | ==== Atrybuty a callbacki ==== | + | For this attribute the **ask_console** callback function will be called, which will get the value of the attribute **day**. |
| - | Callbacki związane są z atrybutami w języku HMR - każdy atrybut ma dwa pola niezbędne do ustalenia jeśli chcemy korzystać z callbacków: | + | |
| - | * //comm// - określające kiedy callback zostanie wywołany (//in// albo //out//) | + | |
| - | * //callback// - nazwa i lista parametrów do wywołania | + | |
| - | Za definicję callbacku odpowiedni jest predykat //xcall// umieszczany w pliku HMR. Na poniższym przykładzie pokazano wykorzystanie mechanizmu JPL do utworzenia callbacku napisanego w Javie. | + | ==== Callbacks and attributes ==== |
| + | In HMR, callbacks are related to attributes. For each attribute two properties must be defined in order to use callbacks: | ||
| + | * //comm// - defines when the callback is executed (possible values: //in// or //out//) | ||
| + | * //callback// - the name and the list of parameters of the required callback. | ||
| + | HMR provides //xcall// predicate that allows for callback definition. | ||
| + | The following example shows the JPL mechnism, which is used to create a callback written in Java. | ||
| <code> | <code> | ||
| xcall ask_symbolic_GUI : [AttName] >>> (jpl_new('skeleton.RequestInterface',[],T), | xcall ask_symbolic_GUI : [AttName] >>> (jpl_new('skeleton.RequestInterface',[],T), | ||
| Linia 82: | Linia 93: | ||
| </code> | </code> | ||
| - | ==== Języki programowania ==== | + | ==== Programming languages ==== |
| - | Callbacki dla interpretera HeaRT mogą być zaimplementowane w jednym z następujących języków: | + | HeaRT supports the callbacks written in: |
| * Prolog | * Prolog | ||
| * XPCE | * XPCE | ||
| * Java | * Java | ||
| === Prolog === | === Prolog === | ||
| - | Są to zwykłe predykaty w języku Prolog: | + | Prolog-based callbacks are an ordinary Prolog predicates. |
| <code> | <code> | ||
| xcall ask_console : [AttName] >>> (write('Type value for attribute: '), | xcall ask_console : [AttName] >>> (write('Type value for attribute: '), | ||
| Linia 96: | Linia 107: | ||
| </code> | </code> | ||
| - | **Ćwiczenie** | + | **Exercise** \\ |
| - | Aby uruchomić wnioskowanie bezpośrednio z interpretera HeaRT, należy pobrać kod interpretera: {{:hekate:heart-m3.tar.gz}} i uruchomić go poleceniem //heart//. W celu skompilowania modelu XTT zapisanego w pliku HMR należy po uruchomieniu HeaRT wpisać w konsoli Prologa //[nazwa-pliku-hmr]// - zwyczajnie skompilować ten plik tak jak każdy inny kod Prologu. Następnie w celu uruchomienia wnioskowania należy wpisać polecenie <code>gox(current, ListaTabelDoPrzetworzenia, ddi)</code>. | + | In order to run inference process directly from HeaRT interpreter you must: |
| - | Uruchom wnioskowanie dla poniższego modelu: {{:pl:dydaktyka:piw:2010:systemy_ekspertowe:thermostat-clb-pl.pl|}} | + | * download the source code of HeaRT {{:hekate:heart-m3.tar.gz}}, |
| + | * run it by typing //heart//, | ||
| + | * in order to complie XTT model in the form of HMR type in console: //[name-of-hmr-file]//, | ||
| + | * run the //gox// command:<code>gox(current, ListOfProcessedTables, ddi)</code> | ||
| + | Run the inference for the following model: {{:pl:dydaktyka:piw:2010:systemy_ekspertowe:thermostat-clb-pl.pl|}} | ||
| === XPCE === | === XPCE === | ||
| - | Są to predykaty w języku Prolog wzbogacone o funkcje XPCE. Aby zapewnić jednak oprawne działanie interpretera HeaRT nalezy korzystać z tego szkieletu: | + | The XPCE-based callbacks consist of the ordinary Prolog predicates that are enriched by XPCE functions. |
| + | In order to assure the correct integration with HaeRT, the following schema must be used: | ||
| <code> | <code> | ||
| xcall xpce_ask_numeric: [AttName] >>> ( | xcall xpce_ask_numeric: [AttName] >>> ( | ||
| dynamic(end), | dynamic(end), | ||
| - | % Ciało callbacku przygotowujace okienko do wyświetlenia i wyświetlające je | + | % The body of the callback, which prepares a dialog to appear. |
| repeat, | repeat, | ||
| - | %Oczekiwanie na wciśnięcie przez użytkownika przycisku OK | + | % Waiting for OK button |
| send(@display,dispatch), | send(@display,dispatch), | ||
| end,!, | end,!, | ||
| Linia 114: | Linia 129: | ||
| </code> | </code> | ||
| - | Przykład callbacku wczytującego liczbę z określonego zakresu pokazany jest poniżej: | ||
| + | The example of the callback that reads a value from the range [Min; Max] is presented below: | ||
| <code> | <code> | ||
| xcall xpce_ask_numeric: [AttName] >>> (alsv_domain(AttName,[Min to Max],numeric), | xcall xpce_ask_numeric: [AttName] >>> (alsv_domain(AttName,[Min to Max],numeric), | ||
| Linia 130: | Linia 145: | ||
| </code> | </code> | ||
| - | **Ćwiczenie** | + | **Exercise** \\ |
| - | Uruchom wnioskowanie dla przykładu z bankomatem i prześledź działanie callbacków: | + | Run the inference mechanism for the ATM example and trace the callback mechanism: |
| * {{:pl:dydaktyka:piw:2010:systemy_ekspertowe:cashpoint-clb-xpce.pl|}} | * {{:pl:dydaktyka:piw:2010:systemy_ekspertowe:cashpoint-clb-xpce.pl|}} | ||
| === Java === | === Java === | ||
| - | Są to programy napisane w języku Java uruchamiane przez prolog przy użyciu JPL. Aby wykorzystać ten mechanizm należy korzystać ze specjalnie przygotowanych do tego klasy: | + | The Java-based callbacks are the Java programs that are executed by prolog with the help of JPL. |
| - | * DataFetcher.java - klasa abstrakcyjna którą muszą rozszerzać wszystkie callbacki | + | To exploit this mechanism, the following classes mysu be used: |
| - | * RequestInterface.java - Kontroler | + | * DataFetcher.java - an abstract class that must be inherited by all the callbacks |
| - | * Response.java - klasa przechowująca dane odebrane od użytkownika. | + | * RequestInterface.java - controller |
| + | * Response.java - class that stores a data retrieved from a user. | ||
| | | ||
| - | W celu ulatwienia implementacji niektórych callbacków, przygotowano zbiór podstawowych komponentów do pobierania danych od użytkownika: | + | The set of basic components, which can be used to the retrieval data from a user, is prepared to facilitate the callbacks implementation. |
| - | * ComboBoxFetcher.java - przyjmuje listę wartości z jakich można wybierać. Zwraca jedną wybraną wartość | + | * **ComboBoxFetcher.java** - creates a list of selectable values. It returns one (selected) value. |
| - | * SliderFetcher.java - przyjmuje przedział wartości numerycznych między którymi można wybierać. Zwraca jedna wybraną wartość. | + | * **SliderFetcher.java** - allowf for selecting a value from a given range of values. It returns one (selected) value. |
| - | * TwoListsFetcher.java - przyjmuje listę wartości jakich można wybierać i zwraca również listę wybranych wartości. | + | * **TwoListsFetcher.java** - creates a list of selectable values. It returns list of all selected values. |
| - | * ComboGUI.java - GUI dla ComboBoxFetcher | + | * **ComboGUI.java** - GUI for ComboBoxFetcher |
| - | * SliderGUI.java - GUI dla SliderFetcher | + | * **SliderGUI.java** - GUI for SliderFetcher |
| - | * TwoListsGUI.java - GUI dla TwoListsFetcher | + | * **TwoListsGUI.java** - GUI for TwoListsFetcher |
| + | Download a source code {{:hekate:callbackslibrary.zip|here}}. | ||
| - | Kod źródłowy klas do pobrania {{:hekate:callbackslibrary.zip|tutaj}}. | + | == Example == |
| - | + | In order to use some of the above components to create callback, you must go through the following steps: | |
| - | ==Przykład== | + | - Compile the source code <code>javac callbacks/input/*.java skeleton/*.java</code> and move it to the HMR file directory. |
| - | Aby wykorzystać któryś z komponentów Java do napisania callbacku, należy wykonać następujące kroki: | + | - Modify the HMR file by adding the //callback// filed to the appropriate attributes. |
| - | - Skompilować kod źródłowy <code></code> i umieścić go w katalogu z plikiem HMR | + | - Define the value of this filed by entering the name of the callback as well as a list of parameters i.e. <code>callback: [ask_symbolic_GUI,[day]]</code> |
| - | - Odpowiednio zmodyfikować plik HMR dopisując atrybutom pole //callback// i uzupełniając go nazwą i listą parametrów jakie callback przyjmuje, np. <code>callback: [ask_symbolic_GUI,[day]]</code> | + | - Add the //xcall// predicates to the HMR file, which execute a given callback:<code> |
| - | - Dopisać predykaty //xcall// do pliku HMR, definiujące wywołanie callbacka, np.:<code> | + | |
| xcall ask_symbolic_GUI : [AttName] >>> ( | xcall ask_symbolic_GUI : [AttName] >>> ( | ||
| - | %Tworzymy obiekt kontrolera: | + | % Creating controller |
| jpl_new('skeleton.RequestInterface',[],T), | jpl_new('skeleton.RequestInterface',[],T), | ||
| - | %Przygotowujemy listę parametrów | + | % Creating a list of params |
| alsv_domain(AttName,Domain,symbolic), | alsv_domain(AttName,Domain,symbolic), | ||
| Params = [AttName|Domain], | Params = [AttName|Domain], | ||
| term_to_atom(Params, AtomParams), | term_to_atom(Params, AtomParams), | ||
| - | %Wywołujemy callback i podajemu my listę parametrów znajdującą sie | + | % Execute the callback with the params contained by AtomPArams term. |
| - | %w termie AtomPArams. Wartosc zwrócona przez callback znajdzie się | + | % The result will be stored in Answer term. |
| - | %w termie Answer. | + | |
| jpl_call(T,request,['callbacks.input.ComboBoxFetcher',AtomParams],Answer), | jpl_call(T,request,['callbacks.input.ComboBoxFetcher',AtomParams],Answer), | ||
| - | %Zamieniamy zwróconą wartość na term i dodajemy go do bazy faktów | + | % Map the returned value into term and add it the the factbase |
| atom_to_term(Answer,Answer2,_), | atom_to_term(Answer,Answer2,_), | ||
| alsv_new_val(AttName,Answer2)). | alsv_new_val(AttName,Answer2)). | ||
| </code> | </code> | ||
| - | - Uruchomić HeaRT w katalogu z plikiem HMR, skompilować ten plik i uruchomić wnioskowanie. Callbacki powinny zostać uruchomione. | + | - Go to HMR file directory. |
| + | - Run HeaRT tool. | ||
| + | - Compile HMR file. | ||
| + | - Run the inference mechanism. | ||
| + | - The callback should be executed. | ||
| + | |||
| + | **Exercise 1** \\ | ||
| + | Download the file {{:pl:dydaktyka:piw:2010:systemy_ekspertowe:kardio.zip|}} and run the inference for the HMR file. | ||
| - | **Ćwiczenie** | + | **Exercise 2** \\ |
| - | Pobierz poniższy kod [[paczka.zip]]. I dla pliku HMR znajdującego się w archiwum uruchom wnioskowanie. | + | - Run HeaRT and load HMR {{:pl:dydaktyka:piw:2010:systemy_ekspertowe:cashpoint-clb-xpce.pl|file}}. |
| + | - Then run the infenrence mechnism using predicate (//gox/3//). | ||
| + | - Add a new XPCE-based callback, which would present the results of the inference. | ||
| + | - Download HMR {{:pl:dydaktyka:piw:2010:systemy_ekspertowe:thermostat-clb-pl.pl|file}}. | ||
| + | - Add (modify an existing Prolog-based) a new JAVA-based callbacks in the same way as in the previous section. | ||
| - | === Ćwiczenie === | ||
| - | - Uruchom interpreter HeaRT, wczytaj [[plik]] HMR i uruchom wnioskowanie predykatem (//goxio/3//). Dopisz callback wyświetlający wynik wnioskowania w XPCE. | ||
| - | - Pobierz ten {{:pl:dydaktyka:piw:2010:systemy_ekspertowe:thermostat-clb-pl.pl|plik}} HMR i dopisz (zmodyfikuj istniejące wersje prologowe) do niego callbacki w Javie bazując na przykładzie z poprzedniej sekcji. | ||
| + | ===== Komentarze ===== | ||
| + | Z braku lepszego miejsca tutaj studenci wpisują komentarze natury ogólnej do tego lab. 8-) | ||
