CHAPTER 2: SYSTEM COMPONENTS

TME 3033 Expert Systems

Objectives

Able to understand the three views in ES

End user view

Knowledge engineer view

Tool builders view

The five blind man from the Hindustan

There were five men of Hindustan,to learning much inclined,Who went to see an elephant,though all of them were blind,That each by observationmight satisfy his mind.

End User View

A KBS consists of three components (user perspective): the intelligent program, the user interface, and a problem specific database.

a) The intelligent program - contains all of the intelligence of the system. The system is simply a black box that operates according to some unknown logic and derives the results that he wants.

b) The user interface to provide the end user with a friendly means of communicating with the intelligent program. Provide convenient interaction using menus, natural language, and/or graphical displays.

c) The problems specific database contains all the information provided by the user about the current problem and all conclusions that the intelligent program has been able to derive.

Purposes of interface:

Enabling the intelligent program to pose questions to the user about the problem at hand

Providing explanations about why it (the intelligent program) is asking particular questions

Allowing then user to query the intelligent program as to why or how a particular decision was made

Displaying the derived results

Providing graphic output for the derived results

Allowing the user to save or print results.

Users view of KBS

User

interface

Intelligent

program

Database

User

Knowledge Engineers View

From KEs view, a KBS consists of two major components:

The intelligent program

Is the product developed for the end user.

The development shell

Is a set of tools that eases the creation of the knowledge within the intelligent program.

Development Shell Intelligent Program

Knowledge acquisition

tool

Test case database

Developers interface

Knowledge base

Inference engine

Figure 1: Knowledge Engineers View of a Knowledge-based System

Intelligent Program

Two components that compose the intelligent program:

Knowledge base (KB)

Inference engine

KB contains all of the relevant, domain specific, problem-solving knowledge that has been gathered by KE.

KB can be viewed from two perspectives: its nature (whether it is algorithmic or heuristic) and its format (predicate, rules, frames, etc).

Intelligent Program (cont.)

Inference engine is the interpreter of the knowledge stored in the knowledge base.

It examines the contents of the knowledge base and the data accumulated about the current problem and derives additional data and conclusions.

Although there are various means for representing knowledge in a KE (e.g., rules, frames), the inference engines must support the representation scheme appropriate for the application and use by the system developer.

Expert system architecture (1)

The inference engine and knowledge base are separated because:

the reasoning mechanism needs to be as stable as possible;

the knowledge base must be able to grow and change, as knowledge is added;

this arrangement enables the system to be built from, or converted to, a shell.

Expert system architecture (2)

It is reasonable to produce a richer, more elaborate, description of the typical expert system.

A more elaborate description, which still includes the components that are to be found in almost any real-world system, would look like this:

Expert system architecture (2)

Expert system architecture (2)

The system holds a collection of general principles which can potentially be applied to any problem - these are stored in the knowledge base.

The system also holds a collection of specific details that apply to the current problem (including details of how the current reasoning process is progressing) - these are held in working memory.

Both these sorts of information are processed by the inference engine.

Expert system architecture (2)

Any practical expert system needs an explanatory facility. It is essential that an expert system should be able to explain its reasoning. This is because:

it makes it easier to debug the system.

Expert system architecture (2)

Expert system architecture (2)

It is not unreasonable to include an expert interface & a knowledge base editor, since any practical expert system is going to need a mechanism for efficiently building and modifying the knowledge base.

Expert system architecture (2)

As mentioned earlier, a reliable expert should be able to explain and justify his/her advice and actions.

The Development Shell Assists the KE in structuring, debugging, modifying, and expanding

the knowledge gathered from the expert.

Typically contains three components:

i. A knowledge acquisition tool

Assists in the construction of the KB (KB editor)

Provides a view of the knowledge and allows the KE to make whatever changes are desired.

ii. A test case database

Verifying any changes made in KB are improvements, not degrade the problem-solving abilities of the KBS.

iii. Developers interface

Same as the interface seen by the end user, except that it contains additional features to assist the KE in the development process.

Allow the KE to exercise the KB as it is being modified and tested.

Tool Builders View

Very similar with KEs view, just differs in focus (refer figure 2).

Concerned with providing an adequate set of tools for the KE to ease the KEs task in building the KBS.

When examining the KB, he worries about what problems the KE will try to solve using this system.

Database

- Maintain trace?

Knowledge acquisition tool

-How detailed?

-Testing:

- completeness

- consistency

- conflicts

Test case database

- Should this exist?

Users interface

-Explanation structure?

-features?

Development Shell Intelligent Program

Knowledge base

-Rules?

-Semantic networks?

-Frames?

Inference engine

- Reasoning scheme?

- Agenda of tasks?

- Inexact reasoning?

- Which solutions?

Figure 2: Tools Builders View of a Knowledge-based System

KBS Tools

There are two methods for developing a KBS:

1. Using tools.

2. Developing a system from scratch.

A development tool is a software package that contains some or all of the components and features.

KE uses this package to develop a Knowledge Base and possibly a specialized user interface.

Such tools are called expert system shells or widely known as knowledge-based shells or shells.

KBS Tools: Shells

Classes of shells according to the knowledge representation paradigm that they support:

Inductive shells

The simplest shells.

KE will specifies example cases as a matrix of known data (or premises) and their resulting effects (or conclusion).

This matrix is then converted into a decision tree or a set of IF-THEN statements.

Rule-based shells

Range from the simple to the complex.

Simple rule-base just like a decision tree with good user interfaces limited to solving fairly simple problems.

Complex rule-base structured the rules inti subsets and provide extensive rule-editing features

KBS Tools: Shells

Hybrid shells

Support multiple knowledge representation paradigm as well as various reasoning schemes.

Quite complex but powerful.

Expensive but capable to handle wide range of problems.

Special purpose shells

Specifically designed for particular types of problems.

E.g.: one type of special purpose shells specializes in the diagnosis of process control systems. However, it should be noted that because it is designed for a highly specialized domain, it cannot be comfortably used for many other types of problems.

KBS Tools: Develop from scratch

Need more time and effort.

KE will not only doing normal function as a knowledge gatherer, but the function of tool builder as well.

Advantages:

KE is not tied to the constraints imposed by the tool builder.

When bugs appear in the shell, the KE does not need access to another individual (the tool builder) for support in correcting these bugs.