Satisfacción del Huésped

The C Language Integrated Production System, CLIPS, is a shell for developing expert systems. It was designed at NASA/Johnson Space Centre to allow artificial intelligence research, development, and delivery on conventional computers. The primary design goals for CLIPS are portability, efficiency, and functionality. For these reasons the system has been written in the C Language. Because of its high portability, CLIPS has been installed on a wide variety of computers ranging from PCs to CRAY supercomputers. CLIPS is used by many research and commercial establishments for a variety of applications such as agricultural research (Texas A&M University), diagnosing plant diseases (University of Arizona) and scheduling and fault management of space communications and tracking network (NASA).

CLIPS is a forward chaining rule-base language that has inferencing and representation capabilities similar to those of OPS5. The system contains an inference engine and a language syntax that provides a framework for the construction of an expert system. It also includes tools for debugging an application. CLIPS is based on the RETE algorithm [30], which enables very efficient pattern matching. The basic elements of CLIPS are:

1. Fact-list - a global memory of data recording the current state of the system 2. Knowledge-base - contains all domain knowledge as rules

3. Inference Engine - controls overall execution

The CLIPS systems was chosen primarily because it was written in C, but also because of its popularity and easy of use. The fact that CLIPS is written in C, enables the expert system to be encapsulated within the C4-4- Generic Interface Object and allows easy modification. As evidence of this easy of modification there is already a Parallel version of CLIPS called PCLIPS [39].

The CLIPS syntax is very similar to LISP and is straightforward to leam. It uses the familiar LISP parentheses and prefix notation. Rules are divided into a left-hand side (LHS) and a right-hand side (RHS) with an equal sign/greater than symbol construct (=>) used as a separator. A typical rule looks like this:

C hapter 5 The OrberonEn v iro n m e n t___________ 79

(defrule dont-walk (status walking)

(or

(red-light)

(walk-sign dont walk) (police say dont walk))

= >

(fprintout t "Don't walk" crlg) )

When the facts necessary to match all the patterns on the LHS are present, the rule fires and the RHS is evaluated or executed. If several rules are able to Ore on a given set of facts, they are placed on an agenda and fired sequentially. Usually the most specific, pertinent rule is placed at the head of the agenda so it executes first. A rule’s priority can be altered through assignment of a salience value, which can range from -10,000 to

10,000.

Pattern matching occurs on the LHS, and CLIPS allows for literal pattern matching on single and multiple-field variables. Variables are proceeded by a question mark (?) and multiple-field variables by a dollar sign and question mark together($?). Multiple-field variables add a simple list-processing capability to CLIPS, and several functions are available for manipulating them. In addition to the use of variables on the LHS, rules can be constrained through the use of included functions and predicates or through user- defined functions.

The RHS describes the actions taken after a rule fires. These actions can include asserting new facts into the fact list, call user defined functions, handle input and output, perform mathematical functions using the basic or extended math package, or make systems calls. Standard programming constructs such as IF..THEN..ELSE and W HILE..END structures can be used.

The CLIPS system provides a convenient and efficient development environment. Rules and facts can be entered interactively from the prompt or entered into a file via the built in EMACS-style editor and load into the system later. The development environment is very similar to many LISP systems. One of CLIPS’s strong points is its easy extendibility through the user-definable functions which can be easily added in the C language. The function below called userfuncs is the repository for all user-defined functions.

C hapter 5 The Orberon Environm ent___________________________________ 80

/**********************************************★********************/

/* U S R F U N C S : The function w h i c h informs CLIPS of any user */

/* defined functions. To define functions, either */

/* this function must be replaced by a function w i t h the*/

/* same name within this file, or this function can be */

/* deleted from this file and included in another file. */

/* User defined functions may be included in this file */

/* or other files. */

/* Example of redefined usrfuncs: */

/* u s r f u n c s () */ / * { V /* d e f i n e _ f u n c t i o n (" f u n l " ,'i ',f u n l , " f u n l " ); */ /* d e f i n e _ f u n c t i o n (" o t h e r " ,'f ',o t h e r , " o t h e r " ); */ / * ] V /*******************************************************************/ e x p _ s y s : :u s r f u n c s () { d e f i n e _ f u n c t i o n (* N e t _ c h e c k " ,'s ',(F P ) n e t _ c h e c k , " n e t _ c h e c k " ); d e f i n e _ f u n c t i o n (*Net_load" ,'i ' , (FP)net_load, " n e t _ l o a d " ); d e f i n e _ f u n c t i o n (* N e t _ t r a i n " ,'i ' ,(F P ) n e t _ t r a i n ," n e t _ t r a i n " );

d e f i n e _ f u n c t i o n (" N e t _ w i n " ,'i ',(F P ) n e t _ w i n , " n e t _ w i n " ); // Icon Change d e f i n e _ f u n c t i o n (" E S _ l o a d " ,'i ',(F P ) e s _ l o a d , " e s _ l o a d " ); // Chaining d e f i n e _ f u n c t i o n (" E S _ r u n " ,'i ', ( F P ) e s _ r u n , " e s _ r u n " ); // Chaining d e f i n e _ f u n c t i o n ( " E S _ a s s e r t " ,'v ' , ( F P ) e s _ a s s e r t , " e s _ a s s e r t " ); // Chaining

d e f i n e _ f u n c t i o n (" E S _ s l o w _ a s s e r t " , 'v', ( F P ) e s _ s l o w _ a s s e r t , " e s _ s l o w _ a s s e r t " ); // Chaining

]

The user-definable function in CLIPS was used to specify the “interface predicates” that were added into the CLIPS language syntax. These interface predicates allow the expert system to access other information processing objects. For example to interrogate a neural network, the expert system rulebase would use the Net_check interface predicate in one of its rules.

The CLIPS expert system was converted into an object for use within the

Or ber o n environment by firstly ensuring that it conforms to C-n- standards such as

prototyping. This is required to ensure that the CLIPS code will compile using C++. The next stage is to inherit from the Generic Interface Object the messages that the expert system is going to respond to from other processing techniques.

The expert system object must now be constructed. This is done by deriving the expert system object from the Generic Interface Object. The expert system object will have inherited the interface functions required to access the other processing objects, namely the neural network object. The expert system object was completed by defining all the functions and the global data from the “wrapped” C system that will be used privately inside the expert system and the functions that will be made public to the other objects i.e. the interface functions. The last task was to include the type of output window required for the expert system. There are two types of windows available at present, one is a command line shell window and other is a CURSES window that understands commands from the C Curses package [5]. The expert system object uses a command line shell window to allow the user to type instructions at a command line. Figure 5.7 shows several expert systems in operation within the Or ber o nenvironment. Once these simple steps are

Chapter 5 The Orberon Environm ent 81

com pleted the expert system object is ready to be com piled and linked into the Orberon

environment. Cxp^fl System Window Pnnh TMt Anuyfv o i m n » T M t H e tero g en eo ^ Environment IPS) < n n ) P R O F I T T R E N D R N R L R Y S I S ■ M C O N S U L T A T I O N SYSTEM ( Neurol Network Sheli Engine BlagnoeK Expert Syetee

i t th e working t t s t e of th e engine

( n o m e l/m e e t i e f e c to ry /d o ee-n o t-i t e r t )? u n ee tisfecto ry ■ th e engine slu g g ish <yes/no)? yes

the engine m isfire (yes/no)? yes th e engine knock (yes/no)? no s the output of th e engine low <yes/no)? yes

t is the s trfe c * s t a t e of th e p o in ts (norm el/bim ed/contem insteU)? normal

Ejq>ert^stem Shell

Editor (vi)

IN ITIft SUM INVESTED I » 246.00 NUMBER OF SHARES INVESTED IN I 100 YESTERDAYS SHARE PRICE

TOTAL PROFIT TO DATE CURRENT RISK LEVEL Repairs:

Clean th e fuel lin e . P oint gap adjustm ent.

n ter the Day <ie Hon, Tue Wed e tc ) : Non the Month <Jan Feb Mar e tc ) : Dec ru le s fire d

n te r the Closing P rice fo r the I m es ted Co#par% : 2.45 n te r the Loss Limit fo r y o ir investment : 50 Chain TmI

CLIPS (V4.30 5/5/89) :LIPS> (lo ad "CHAIN.clp") 're c e s s in g d e ffa c ts block Success 're c e s s in g d e ffa c ts block S ta rt Compiling r u le : S ta rt »j Compiling r u l e : Success *J ZLIPS) (r e s e t) 1IPS> (r»n)

1»» STARTING CHADCD EXPERTS SYSTEM TEST » » Execution S ta rted From C alling Expert Syst

CLIPS (V4.30 5Æ /89) U P S )

XIPS) (f a c ts )

-1 (Chained R ir Successful) IPS)

» = > » Interro g atin g Neoral Network to obtain P ro fit » = » > Trend fo r the l a s t two weeks

arsenal P r o f it Trend is Decreasing

» % = )» In terro g atin g Neu-al Network to o btain Share »% =>» Index Trend fo r the la s t qu arte r

t l y Share Index is Decreasing » » CHAIICD Expert System Test SUCCESSFUL!

» » RETURNING SUCCES FACT To C alling Expert Syst

RECIMENDAT ONS TOTAL PROFIT TO DATE = t -1.00 CURRENT RISK ÜEWL % 1.25 2 ru le s f ir e d

From th e Inform ation Supplied and th e c o rren t tren d in p r o f it movement. I t would be recommended th a t you m aintain th e curren t level of investm ent.

Figure 5.7 — Expert system windows displaying different functions.