Implementing an Animal Expert System

An example from AI for Beginners Curriculum.

In this sample, we will implement a simple knowledge-based system to determine an animal based on some physical characteristics. The system can be represented by the following AND-OR tree (this is a part of the whole tree, we can easily add some more rules):

Our own expert systems shell with backward inference

Let's try to define a simple language for knowledge representation based on production rules. We will use Python classes as keywords to define rules. There would be essentially 3 types of classes:

• Ask represents a question that needs to be asked to the user. It contains the set of possible answers.
• If represents a rule, and it is just a syntactic sugar to store the content of the rule
• AND/OR are classes to represent AND/OR branches of the tree. They just store the list of arguments inside. To simplify code, all functionality is defined in the parent class Content

In our system, working memory would contain the list of facts as attribute-value pairs. The knowledgebase can be defined as one big dictionary that maps actions (new facts that should be inserted into working memory) to conditions, expressed as AND-OR expressions. Also, some facts can be Ask-ed.

To perform the backward inference, we will define Knowledgebase class. It will contain:

• Working memory - a dictionary that maps attributes to values
• Knowledgebase rules in the format as defined above

Two main methods are:

• get to obtain the value of an attribute, performing inference if necessary. For example, get('color') would get the value of a color slot (it will ask if necessary, and store the value for later usage in the working memory). If we ask get('color:blue'), it will ask for a color, and then return y/n value depending on the color.
• eval performs the actual inference, i.e. traverses AND/OR tree, evaluates sub-goals, etc.

Now let's define our animal knowledgebase and perform the consultation. Note that this call will ask you questions. You can answer by typing y/n for yes-no questions, or by specifying number (0..N) for questions with longer multiple-choice answers.

Using Experta for Forward Inference

In the next example, we will try to implement forward inference using one of the libraries for knowledge representation, Experta. Experta is a library for creating forward inference systems in Python, which is designed to be similar to classical old system CLIPS.

We could have also implemented forward chaining ourselves without many problems, but naive implementations are usually not very efficient. For more effective rule matching a special algorithm Rete is used.

We will define our system as a class that subclasses KnowledgeEngine. Each rule is defined by a separate function with @Rule annotation, which specifies when the rule should fire. Inside the rule, we can add new facts using declare function, and adding those facts will result in some more rules being called by forward inference engine.

Once we have defined a knowledgebase, we populate our working memory with some initial facts, and then call run() method to perform the inference. You can see as a result that new inferred facts are added to the working memory, including the final fact about the animal (if we set up all the initial facts correctly).