Reasoning and Agents

Chapter 3
Knowledge Representation
in AI

Dr. Fatma M. Talaat

 Contents

1. Chapter 1: Intelligent Agents

2. Chapter 2: Search based Planning

3. Chapter 3: Knowledge Representation in AI

4. Chapter 4: Logical Representation and Planning

5. Chapter 5: Reasoning in Artificial intelligence

6. Chapter 6: Scaling Planning for Complex Tasks

7. Chapter 7: Acting in Uncertain (real world) Environments

 Chapter 3:
Knowledge Representation in AI

3
 Contents
1. Knowledge Representation in AI

2. Knowledge-Based Agent in Artificial Intelligence

3. The architecture of knowledge-based agent

4. Various levels of knowledge-based agent

5. Main Components of KBA

6. Types of knowledge

7. AI knowledge cycle

8. Operations Performed by KBA

9. Approaches to design a knowledge-based agent

10. Approaches to store knowledge in knowledge representation

11. Ontological engineering

12. Properties of a Knowledge Representation System

13. Techniques used for Knowledge Representation

 1. Knowledge Representation in AI

There are three factors which are put into the machine, which makes it valuable:

1. Knowledge: The information related to the environment is stored in the machine.

2. Reasoning: The ability of the machine to understand the stored knowledge.
3. Intelligence: The ability of the machine to make decisions on the basis of the stored information.
 1. Knowledge Representation in AI

• Knowledge Representation and Reasoning (KR, KRR) is the part of Artificial intelligence which
concerned with AI agents thinking and how thinking contributes to intelligent behavior of agents.

• Knowledge: is awareness or familiarity gained by experiences of facts, data, and situations.

• Reasoning: is the action of thinking about something in a logical, sensible way.

2. Knowledge-Based Agent in Artificial Intelligence

• An intelligent agent needs knowledge about the real world for taking decisions and reasoning to act
efficiently.

• Knowledge-based agents: are those agents who have the capability of maintaining an internal state
of knowledge, reason over that knowledge, update their knowledge after observations and take
actions.

• These agents can represent the world with some formal representation and act intelligently.
2. Knowledge-Based Agent in Artificial Intelligence

A knowledge-based agent must able to do the following:

• An agent should be able to represent states, actions, etc.

• An agent should be able to incorporate new percepts.
• An agent can update the internal representation of the world.
• An agent can deduce the internal representation of the world.
• An agent can deduce appropriate actions.
3. The architecture of knowledge-based agent

• The following diagram is representing a generalized architecture for a knowledge-based agent.

• The knowledge-based agent (KBA) takes input from the environment by perceiving the environment.
• The input is taken by the inference engine of the agent and which also communicate with KB to
decide as per the knowledge store in KB.
• The learning element of KBA regularly updates the KB by learning new knowledge.
 4. Various levels of knowledge-based agent

A knowledge-based agent can be viewed at different levels which are given below:

1. Knowledge level
• Knowledge level is the first level of knowledge-based agent, and in this level, we need to specify what
the agent knows, and what the agent goals are.

• With these specifications, we can fix its behavior.

• For example, suppose an automated taxi agent needs to go from a station A to station B, and he knows
the way from A to B, so this comes at the knowledge level.
• Treatment chosen by doctor for a patient for a disease is based on current symptoms plus some
knowledge from the textbooks plus experience.
 4. Various levels of knowledge-based agent

2. Logical level:
• At this level, we understand that how the knowledge representation of knowledge is stored.
• At this level, sentences are encoded into different logics.
• At the logical level, an encoding of knowledge into logical sentences occurs.
• At the logical level we can expect to the automated taxi agent to reach to the destination B.
 4. Various levels of knowledge-based agent

3. Implementation level:
• This is the physical representation of logic and knowledge.
• At the implementation level, agent performs actions as per logical and knowledge level.
• At this level, an automated taxi agent actually implement his knowledge and logic so that he can reach
to the destination.
5. Main Components of KBA

Knowledge-based agents are composed of two main parts:

1) Knowledge-base.
2) Inference system.
5.1. Knowledge base

Knowledge base: is a central component of a knowledge-based agent, it is also known as KB.

• It is a collection of sentences (here 'sentence' is a technical term and it is not identical to sentence in
English).

• These sentences are expressed in a language which is called a knowledge representation language.
• The Knowledge-base of KBA stores fact about the world.
5.1. Knowledge base

Why use a knowledge base?

• Knowledge-base is required for updating knowledge for an agent to learn with experiences and take
action as per the knowledge.

• Knowledge and reasoning also play a crucial role in dealing with partially observable environment.
 5.2. Inference System

• Inference means deriving new sentences from old.

• Inference system allows us to add a new sentence to the knowledge base.
• A sentence is a proposition about the world.
• Inference system applies logical rules to the KB to deduce new information.

• Inference system generates new facts so that an agent can update the KB.
• An inference system works mainly in two rules which are given as:
1) Forward chaining
2) Backward chaining
 6. Types of knowledge

Following are the various types of knowledge:

1) Meta Knowledge: It is the information/knowledge about

knowledge.
2) Heuristic Knowledge: It is the knowledge regarding a specific
topic.
3) Procedural Knowledge: It gives information about achieving
something.
4) Declarative Knowledge: It is the information which describes a
particular object and its attributes.
5) Structural Knowledge: It describes the knowledge between the
objects.
 6. Types of knowledge

Following are the various types of knowledge:

1. Meta-knowledge:
Knowledge about the other types of knowledge is called Meta-
knowledge.
 6. Types of knowledge

Following are the various types of knowledge:

2. Heuristic knowledge:

• Heuristic knowledge is representing knowledge of some experts

in a filed or subject.

• Heuristic knowledge is rules of thumb based on previous

experiences, awareness of approaches, and which are
good to work but not guaranteed.
 6. Types of knowledge

Following are the various types of knowledge:

3. Procedural Knowledge

• It is also known as imperative knowledge.

• Procedural knowledge is a type of knowledge which is

responsible for knowing how to do something.

• It can be directly applied to any task.

• It includes rules, strategies, procedures, agendas, etc.

• Procedural knowledge depends on the task on which it can be

applied.
 6. Types of knowledge

Following are the various types of knowledge:

4. Declarative Knowledge:
• Declarative knowledge is to know about something.

• It includes concepts, facts, and objects.

• It is also called descriptive knowledge and expressed in

declarative sentences.

• It is simpler than procedural language.

 6. Types of knowledge

Following are the various types of knowledge:

5. Structural knowledge:

• Structural knowledge is basic knowledge to problem-solving.

• It describes relationships between various concepts such as

kind of, part of, and grouping of something.

• It describes the relationship that exists between concepts or

objects.
 7. AI knowledge cycle

An Artificial intelligence system has the following components for displaying intelligent behavior:

1. Perception
2. Learning
3. Knowledge Representation and Reasoning
4. Planning
5. Execution
 8. Operations Performed by KBA

Following are three operations which are performed by KBA in

order to show the intelligent behavior:

1) TELL: This operation tells the knowledge base what

it perceives from the environment.
2) ASK: This operation asks the knowledge base what
action it should perform.
3) Perform: It performs the selected action.
 8. A generic knowledge-based agent

Following is the structure outline of a generic knowledge-based agents program:

 8. A generic knowledge-based agent

 The knowledge-based agent takes percept as input and returns an action as output.
 The agent maintains the knowledge base, KB, and it initially has some background knowledge of the
real world.
 It also has a counter to indicate the time for the whole process, and this counter is initialized with zero.

Each time when the function is called, it performs its three operations:
• Firstly it TELLs the KB what it perceives.
• Secondly, it asks KB what action it should take
• Third agent program TELLS the KB that which action was chosen.
8. A generic knowledge-based agent

 The MAKE-PERCEPT-SENTENCE generates a sentence as

setting that the agent perceived the given percept at the given
time.

 The MAKE-ACTION-QUERY generates a sentence to ask which

action should be done at the current time.

 The MAKE-ACTION-SENTENCE generates a sentence which

asserts that the chosen action was executed.
 9. Approaches to design a knowledge-based agent

There are mainly two approaches to build a knowledge-based agent:

1. Declarative approach: We can create a knowledge-based agent by initializing with an empty knowledge
base and telling the agent all the sentences with which we want to start with. This approach is called
Declarative approach.

2. Procedural approach: In the procedural approach, we directly encode desired behavior as a program
code. Which means we just need to write a program that already encodes the desired behavior or agent.

 However, in the real world, a successful agent can be built by combining both declarative and
procedural approaches, and declarative knowledge can often be compiled into more efficient procedural
code.
 10. Approaches to store knowledge in knowledge representation

There are mainly four approaches to knowledge representation, which are given below:

1. Simple relational knowledge:

2. Inheritable knowledge.
3. Inferential knowledge.
4. Procedural knowledge.
 10.1. Simple relational knowledge

• It is the simplest way of storing facts which uses the relational method, and each fact about a set of the
object is set out systematically in columns.

• This approach of knowledge representation is famous in database systems where the relationship
between different entities is represented.

• This approach has little opportunity for inference.

 10.1. Simple relational knowledge - Example

Example: The following is the simple relational knowledge representation.

 10.2. Inheritable knowledge

• In the inheritable knowledge approach, all data must be stored into a hierarchy of classes.
• All classes should be arranged in a generalized form or a hierarchal manner.
• In this approach, we apply inheritance property.
• Elements inherit values from other members of a class.

• This approach contains inheritable knowledge which shows a relation between instance and class, and
it is called instance relation.
• Every individual frame can represent the collection of attributes and its value.
• In this approach, objects and values are represented in Boxed nodes.
• We use Arrows which point from objects to their values.
 10.2. Inheritable knowledge

Example:
 10.3. Inferential knowledge

• Inferential knowledge approach represents knowledge in the form of formal logics.

• This approach can be used to derive more facts.
• It guaranteed correctness.

Example: Let's suppose there are two statements:

a. Marcus is a man
b. All men are mortal

Then it can represent as;

man(Marcus)
∀x = man (x) ----------> mortal (x)s
 10.4. Procedural knowledge

• Procedural knowledge approach uses small programs and codes which describes how to do specific
things, and how to proceed.
• In this approach, one important rule is used which is If-Then rule.

• In this knowledge, we can use various coding languages such as LISP language and Prolog language.
• We can easily represent heuristic or domain-specific knowledge using this approach.
• But it is not necessary that we can represent all cases in this approach.
 11. Ontological engineering

• A machine sounds like an empty box unless it is encoded with some features or information.
• Therefore, to make it a valuable machine, it is required to put the necessary knowledge in it.

• So that it could understand it and is able to take the right decisions.

• With the increasing demand for the knowledge representation technique, there was a need for larger
and modular knowledge that could integrate and combine with one another.
 11. Ontological engineering

Ontological engineering is the engineering of such systems which could represent the complex domains
effectively.

• With the help of ontological engineering, the representation of the general concepts such as actions,
time, physical objects, performance, meta-data, and beliefs becomes possible on a large-scale.

• For special type of representations, we require a special type of ontology known as Special ontology.
But for special ontologies, there is a need to move towards a high-level generality.
 11. Ontological engineering

There are two following major characteristics which distinguish general ontologies from the special one:

1. General ontologies should be applicable in every type of special-purpose domains with some domain-
specific axioms.

2. When there is a sufficiently demanding domain, the areas of knowledge should be unified.

• Unfortunately, none of the applications of artificial intelligence make use of the shared/general ontology,
all they use is special ontology.
 12. Properties of a Knowledge Representation System

There are following properties of a Knowledge Representation system:

1) Representational Adequacy: It is the ability of the system to represent all kinds of knowledge needed in a
specific domain.
2) Inferential Adequacy: It is the ability of a knowledge representation system to manipulate the current
stored knowledge so that newly gained knowledge could be added.
3) Inferential Efficiency: It is the ability of the system to directly add new knowledge in the system with
efficiency.
4) Acqusitional Efficiency: It is the ability of the system to automatically acquire new knowledge from the
environment. This leads the system to give more productive result as more knowledge adds up with the
current knowledge.
 13. Techniques used for Knowledge Representation

• There are mainly four ways of knowledge representation which are given as follows:

1. Logical Representation (Logic)

2. Semantic Network Representation
3. Frame Representation
4. Production Rules
 13.1. Logical representation (Logic)

• Logical representation is a language with some concrete rules which deals with propositions and has
no ambiguity in representation.

• Logic: It is the basic method used to represent the knowledge of a machine.

• The term logic means to apply intelligence over the stored knowledge.

• Logical representation means drawing a conclusion based on various conditions.

 13.1. Logical representation (Logic)

Logical representation can be categorized into mainly two logics:

- Propositional Logics
- Predicate logics

Note: We will discuss Prepositional Logics and Predicate logics in later chapters.
 13.1. Logical representation (Logic)

Advantages of logical representation:

• Logical representation enables us to do logical reasoning.
• Logical representation is the basis for the programming languages.

Disadvantages of logical Representation:

• Logical representations have some restrictions and are challenging to work with.
• Logical representation technique may not be very natural, and inference may not be so efficient.

Note: Do not be confused with logical representation and logical reasoning as logical representation is a
representation language and reasoning is a process of thinking logically.
 13.2. Semantic Network Representation

• In Semantic networks, we can represent our knowledge in the form of graphical networks (graph).
• This network consists of nodes representing objects and arcs which describe the relationship between
those objects.
• Semantic networks can categorize the object in different forms and can also link those objects.
• Semantic networks are easy to understand and can be easily extended.

This representation consist of mainly two types of relations:

• 1. IS-A relation (Inheritance)
• 2. Kind-of-relation
 13.2. Semantic Network Representation

Example: Following are some statements which we need to represent in the form of nodes and arcs.

Statements:
• Jerry is a cat.
• Jerry is a mammal.
• Jerry is owned by Priya.
• Jerry is white colored.
• All Mammals are animal.
 13.2. Semantic Network Representation

https://github.com/HKUST-KnowComp/ASER
 13.3. Frame Representation

• Frames: In this technique, the knowledge is stored via slots and fillers.
• As we have seen in DBMS, we store the information of an employee in the database, where:

Similarly, the Slots are the entities and Fillers are its attributes.
They are together stored in a frame.
So, whenever there is a requirement, the machine infers the necessary information to take the decision.
For example, Tomy is a dog having one tail.

• It can be framed as:

 13.4. Production Rules

Production rules system consist of (condition, action) pairs which mean, "If condition then action".

It has mainly three parts:

• The set of production rules.
• Working Memory.
• The recognize-act-cycle.
13.4. Production Rules

 In production rules, agent checks for the condition and if the condition exists then production rule fires
and corresponding action is carried out.

 The working memory contains the description of the current state of problems-solving and rule can
write knowledge to the working memory.
 13.4. Production Rules

Example:
IF (at bus stop AND bus arrives) THEN action (get into the bus)
IF (on the bus AND paid AND empty seat) THEN action (sit down).
IF (on bus AND unpaid) THEN action (pay charges).
IF (bus arrives at destination) THEN action (get down from the bus).
 13.4. Production Rules

Advantages of Production rule:

1. The production rules are expressed in natural language.
2. The production rules are highly modular, so we can easily remove, add or modify an individual rule.

Disadvantages of Production rule:

1. Production rule system does not exhibit any learning capabilities, as it does not store the result of the
problem for the future uses.
2. During the execution of the program, many rules may be active hence rule-based production systems
are inefficient.
14. Knowledge Representation and Reasoning with Answer Set Programming
(ASP)

• Why declarative programming?

Using a promising declarative programming paradigm, namely Answer Set Programming (ASP, sometimes
also Answer Set Prolog), offers unexpected advantages over the popular imperative programming
approach, for example:

- Short solutions (as measured by lines of code)

- Transparency (including readability)
- Reliability
14. Knowledge Representation and Reasoning with Answer Set Programming
(ASP)

• What is ASP and how does it work?

An answer set program consists of given knowledge formulated as facts, rules (head(X) :- body(X).) or
constraints.

The program is loaded by a solver and returns a ―stable model‖. This so called answer set consists of all
facts that can be derived using the given rules and constraints.
14. Knowledge Representation and Reasoning with Answer Set Programming
(ASP)

• Let us consider a famous example from logic about birds and penguins. It is a well known fact that birds
can fly. This can be encoded as an answer set rule:
canFly(X) :- bird(X).

• The rule is read as ―If X is a bird, then X can fly‖. Now let‘s add more knowledge! For example, facts
that tell the unconditional truth, just as seagull ‗Malvin‘ is a bird, but also penguin ‗Roger‘ is one.

canFly(X) :- bird(X).
bird(malvin).
bird(roger).

== MODEL OUTPUT ==
Anwer: 1
bird(malvin) bird(roger) canFly(malvin) canFly(roger)
SATISFIABLE
14. Knowledge Representation and Reasoning with Answer Set Programming
(ASP)

• As a result, the answer set tells us the known facts that Malvin and Roger are birds but also concluded
that they are able to fly. The biology enthusiasts among us know, that penguins are unable to fly thus
the model is wrong!

Seagull ‗Malvin‘ — slightly showing off because he can fly.

14. Knowledge Representation and Reasoning with Answer Set Programming
(ASP)

• In order to get acceptable results we need to add more knowledge in form of facts and integrity
constraints to the program. Here, the model needs to know that Roger is not only a bird but also a
penguin and that there is no bird that is a penguin which is able to fly.

canFly(X) :- bird(X).
bird(malvin).
bird(roger).
seagull(malvin).
penguin(roger).
:- canFly(X), penguin(X).

== MODEL OUTPUT ==
UNSATISFIABLE
14. Knowledge Representation and Reasoning with Answer Set Programming
(ASP)

• This does not bring the expected result and shows how important it is to think thoroughly and very
carefully about the problem as well as the solution. The model tells, like stated by the programmer, that
a bird can fly but there is no advise for birds that belong to the penguin family. To avoid this, we could
add that only birds that are not penguins are able to fly.

canFly(X) :- bird(X), not penguin(X).

bird(malvin).
bird(roger).
seagull(malvin).
penguin(roger).
:- canFly(X), penguin(X).

== MODEL OUTPUT ==
Answer: 1
bird(malvin) bird(roger) seagull(malvin) penguin(roger) canFly(malvin)
SATISFIABLE
14. Knowledge Representation and Reasoning with Answer Set Programming
(ASP)

• Adding this knwoledge in Line [1], the stable model consists of the expected outcome.
canFly(X) :- bird(X), not penguin(X).

Penguin ‗Roger‘ — slightly bored because he cannot fly 

15. Imperative versus declarative programming
.. for solving Sudoku

• Let‘s look at another example to highlight the advantages of ASP mentioned above. Sudoku is a well
known puzzle game and popular for explaining search problems.

• Given an initial 9x9 grid of cells containig numbers between 1 and 9 or blanks, all blanks must be filled
with numbers. You win Sudoko if you find all values such that every row, column, and 3x3 subsquare
contains the numbers 1–9, each with a single occurrence.
15. Imperative versus declarative programming
.. for solving Sudoku
15. Imperative versus declarative programming
.. for solving Sudoku…. 1. Python (imperative)

• The following Code snippet will show how to solve the Sudoku in Python.

size = 9
#empty cells have value zero
matrix = [
[5,3,0,0,7,0,0,0,0],
[6,0,0,1,9,5,0,0,0],
[0,9,8,0,0,0,0,6,0],
[8,0,0,0,6,0,0,0,3],
[4,0,0,8,0,3,0,0,1],
[7,0,0,0,2,0,0,0,6],
[0,6,0,0,0,0,2,8,0],
[0,0,0,4,1,9,0,0,5],
[0,0,0,0,8,0,0,7,9]]
#print Sudoku
def print_sudoku():
for i in matrix:
print (i)
15. Imperative versus declarative programming
.. for solving Sudoku… 1. Python (imperative)

#assign cells and check

def number_unassigned(row, col):
num_unassign = 0
for i in range(0,size):
for j in range (0,size):
#cell is unassigned
if matrix[i][j] == 0:
row = i
col = j
num_unassign = 1
a = [row, col, num_unassign]
return a
a = [-1, -1, num_unassign]
return a
15. Imperative versus declarative programming
.. for solving Sudoku… 1. Python (imperative)

#check validity of number

def is_safe(n, r, c):
#checking in row
for i in range(0,size):
#there is a cell with same value
if matrix[r][i] == n:
return False
#checking in column
for i in range(0,size):
#there is a cell with same value
if matrix[i][c] == n:
return False
row_start = (r//3)*3
col_start = (c//3)*3;
15. Imperative versus declarative programming
.. for solving Sudoku… 1. Python (imperative)

#checking submatrix
for i in range(row_start,row_start+3):
for j in range(col_start,col_start+3):
if matrix[i][j]==n:
return False
return True

#check validity of number

def solve_sudoku():
row = 0
col = 0
15. Imperative versus declarative programming
.. for solving Sudoku… 1. Python (imperative)

#if all cells are assigned then the sudoku is already solved
#pass by reference because number_unassigned will change the values of row and col
a = number_unassigned(row, col)
if a[2] == 0:
return True
row = a[0]
col = a[1]

#number between 1 to 9
for i in range(1,10):
#if we can assign i to the cell or not
#the cell is matrix[row][col]
if is_safe(i, row, col):
matrix[row][col] = i
#backtracking
if solve_sudoku():
return True
15. Imperative versus declarative programming
.. for solving Sudoku… 1. Python (imperative)

#if we can't proceed with this solution

#reassign the cell
matrix[row][col]=0
return False
if solve_sudoku():
print_sudoku()
else:
print("No solution")
15. Imperative versus declarative programming
.. for solving Sudoku… 2. ASP (declarative)
• Let‘s have a look at the ASP code snippet — after initalization, we are able to solve the Sudoku with less
than 10 lines of code!
% Initialize the game (given numbers)
sudoku(1, 1, 5).
sudoku(1, 2, 3).
sudoku(1, 5, 7).
sudoku(2, 1, 6).
sudoku(2, 4, 1).
sudoku(2, 5, 9).
sudoku(2, 6, 5).
sudoku(3, 2, 9).
sudoku(3, 3, 8).
sudoku(3, 8, 6).
sudoku(4, 1, 8).
sudoku(4, 5, 6).
sudoku(4, 9, 3).
sudoku(5, 1, 4).
sudoku(5, 4, 8).
sudoku(5, 6, 3).
sudoku(5, 9, 1).
sudoku(6, 1, 7).
15. Imperative versus declarative programming
.. for solving Sudoku… 2. ASP (declarative)
sudoku(6, 5, 2).
sudoku(6, 9, 6).
sudoku(7, 2, 6).
sudoku(7, 7, 2).
sudoku(7, 8, 8).
sudoku(8, 4, 4).
sudoku(8, 5, 1).
sudoku(8, 6, 9).
sudoku(8, 9, 5).
sudoku(9, 5, 8).
sudoku(9, 8, 7).
sudoku(9, 9, 9).
% define the grid
n(1..9).
x(1..9).
y(1..9).% each field contains exactly one number from 1 to 9
{sudoku(X,Y,N): n(N)} = 1 :- x(X) ,y(Y).% helper
subgrid(X,Y,A,B) :- x(X), x(A), y(Y), y(B),(X-1)/3 == (A-1)/3, (Y-1)/3 == (B-1)/3.% constraints
:- sudoku(X,Y,N), sudoku(A,Y,N), X!=A.
:- sudoku(X,Y,N), sudoku(X,B,N), Y!=B.
:- sudoku(X,Y,V), sudoku(A,B,V), subgrid(X,Y,A,B), X != A, Y != B.
#show sudoku/3.
Thanks!
Any
questions?

69