Rkj@aber.ac.uk CSM6120 Introduction to Intelligent Systems Knowledge Representation 2

rkj@aber.ac.uk

CSM6120Introduction to Intelligent

SystemsKnowledge Representation 2

What we’ve ignored Objects in the world tend to be related to each other

Classes, superclasses & subclasses Part / whole hierarchies Properties are inherited across relationships

The state of the world can change over time Explicit representation of time Frame axiom Non-monotonic reasoning

We must reason without complete knowledgeClosed world assumption

Not all knowledge is “black & white” (later modules) Uncertainty Statistics, fuzzy logic

Classes “I want to buy a basketball”

I want to buy BB27341 (NO) I want to buy an object that is a member of the basketball

class (YES) Objects organized into a hierarchy by class

BB27341 basketballs Basketballs balls

Facts (objects) & rules (classes) All balls are round All basketballs are <size> in diameter BB27341 is red, white and blue BB27341 is a basketball (Therefore BB27341 is round and <size> in diameter)

Inheritance If a property is true of a class, it is true of all

subclasses of that class

If a property is true of a class, it is true of all objects that are members of that class

(If a property is true of a class, it is true of all objects that are members of subclasses of that class)

There are exceptions (to be dealt with later…)

Part / Whole Inheritance A cow has 4 legs

Each leg is part of the cow The cow is in the field

All of the cow’s parts are also in the field The cow is (entirely) brown

All of the cow’s parts are brown The cow is happy

All of the cow’s parts are happy (?)

Note: some properties are inherited by parts, others are not. This is generally made explicit by rules, such as part-of(x,y) and location(y,z) -> location(x,z)

Stuff vs. things Some objects are “stuff”

When you divide the object, its parts are still the same: e.g. butter, snow

“stuff” cannot be referred to with “a” or “an” “Please pass a butter” (?)

Other objects are “things” When you divide them, you destroy them, e.g.

aardvark, snowflake “A snowflake landed on my nose” vs. “A snow landed

on my nose”

Situations and events A state of the world is a “situation”

Divide predicates into “eternal” and “fluent” At(x,y,S) is fluent - S is the situation where it holds Gold(g) is eternal - it is true in all situations

Each action causes a result Result(move-to(x,y),Si) = At(x,y, Si+1)

The frame problem What about everything else?

Result(move-to(x,y), Si) = At(x,y, Si+1) and z, z≠x at(z,w, Si) at(z,w, Si+1)

This is a frame axiom Representing all frame axioms explicitly is a pain

Instead: assume it’s the same if we’re not told it’s different Fluent is true in new situation iff last action made it true, or if

it was true in the previous situation

Real world example: what colour is John’s hair? We assume it hasn’t changed, but maybe he coloured it

today!

Semantic networks Semantic networks are essentially a

generalization of inheritance hierarchies Each node is an object or class

Each link is a relationship is-a (the usual subclass or element relationship) has-part or part-of Any other relationship that makes sense in context

Note: semantic networks predated OOP

Inheritance: follow one member-of link, as many subclass or other links as necessary

Graphical representation Graphs easy to store in a computer

To be of any use must impose a formalism

Jason is 15, Bryan is 40, Arthur is 70, Jim is 74 How old is Julia?

Semantic networks

Because the syntax is the same We can guess that Julia’s age is similar to Bryan’s

Formalism imposes restricted syntax

Knowledge represented as a network or graph

subclasssubclass

haspart

subclass

instance

likes

size

AnimalAnimal

ReptileReptile

ElephantElephant

NellieNellie

MammalMammal

applesapples

largelarge

headhead

AfricaAfricalivesin

Semantic networks

Semantic networks By traversing network we can find:

That Nellie has a head (by inheritance) That certain concepts related in certain ways (e.g.,

apples and elephants) But: meaning of semantic networks not

always well defined Are all Elephants big, or just typical elephants? Do all Elephants live in the “same” Africa? Do all animals have the same head?

For machine processing these things must be defined

Algorithm for inheritance If the current object has a value for the property,

return that value

Otherwise, if the current object is a member of a class, return the value of the property of the class (recursively)

Otherwise, if the current object is a subclass, return the value of the property of the superclass (recursively)

This is depth-first search; stop at the first one found

Defaults and Exceptions Exception for a single object:

Set a property of the object to the (exception) value

Default for a class Set a property of the class to the (default) value If there are multiple default values, the one

“closest” to the object wins

Example All birds can fly Birds with broken wings are birds, but cannot fly Penguins are birds, but they cannot fly Magical penguins are penguins that can fly

Who can fly? Tweety is a bird Peter is a penguin Penelope is a magical penguin

Note that beliefs can be changed as new information comes in that changes the classification of an object

Two useful assumptions Closed World Assumption

Anything that I don’t know is true, I will assume to be false

(Negation as failure in Prolog)

Unique Names Assumption Unique names refer to different objects “Chris and the programmer …” implies Chris isn’t

the programmer Again, Prolog implements this assumption.

Advantages of semantic networks Easy to visualize

Formal definitions of semantic networks have been developed

Related knowledge is easily clustered

Efficient in space requirements Objects represented only once Relationships handled by pointers

Disadvantages of semantic networks Inheritance (particularly from multiple sources

and when exceptions in inheritance are wanted) can cause problems

Facts placed inappropriately cause problems

No standards about node and arc values

Conceptual graphs Semantic network where each graph represents a

single proposition Concept nodes can be

Concrete (visualisable) such as restaurant, my dog Spot Abstract (not easily visualisable) such as anger

Edges do not have labels Instead, conceptual relation nodes Easy to represent relations between multiple objects

Causal, temporal, inheritance networks Causal networks

nodes represent concepts, objects, events links represent causal relationship between these

concepts, objects, events Temporal networks

nodes represent events links represent temporal relationship between

events, like ‘before’, ‘after’,... Inheritance networks (terminologies,

taxonomies) nodes represent concepts links represent class-/subclass-relationship is-a:

superclass – subclass or super-concept / sub-concept

Causal network – example

Classification hierarchy

Inheritance networks nodes represent concepts (events, objects,

actions,...) links represent

super-concept / sub-concept-relationships is-a: specialization / subsumption of concepts

concept-instance-relationships instance-of relationships between concepts role (slot) attributes/features/properties of concept constraints attached to roles, e.g. number of fillers

Closely related to First-Order Predicate Logic

Terminological network – exampleExample:

Concepts: bird, robin, flying-animal, “Speedy”Feature: colouris-a (robin,bird), is-a (bird,flying-animal) Superclassinstance-of (“Speedy”, robin) Instancehas-colour (robin)=“grey” Feature

Task:Express that a typical elephant has legs, usually 4 of them, has a certain colour, and there is a specific elephant named Clyde

elephant, colour, legs, has (usually) 4 legs,”Clyde”

Terminological network - solution

Solution:Concepts: elephant, legs, “Clyde” (instance) or

Clyde (individual concept), (colour and grey)

Roles: has-legs, (has-colour)

Feature: colour

Specific representation of Clyde:

has-legs (elephant, 4)

has-colour (elephant, grey)

instance-of (“Clyde”, elephant)specific object “Clyde”

is-a(Clyde, elephant) individual concept ‘Clyde’

Semantics of KR Languages

• Formal semantics e.g. Predicate Logic Interpretation, derive meaning of complex expressions based on meaning of atomic expressions plus construction mechanism

• Use / reasoninge.g. Spreading activation positive or negative association between concepts; see Neural Networks

Frames Devised by Marvin Minsky, 1974

Incorporates certain valuable human thinking characteristics: Expectations, assumptions, stereotypes.

Exceptions. Fuzzy boundaries between classes

The essence of this form of knowledge representation is typicality, with exceptions, rather than definition

Frames Frames were the next development, allowing

more convenient “packaging” of facts about an object

We use the terms “slots” and “slot values”

mammal: subclass: animal

elephant: subclass: mammal size: large haspart: trunk

Nellie: instance: elephant likes: apples

Frames Frames often allowed you to say which things

were just typical of a class, and which were definitional, so couldn’t be overridden

Frames also allow multiple inheritance (Nellie is an Elephant and is a circus animal)

Elephant: subclass: mammal haspart: trunk * colour: grey * size: large

Frame representations Semantic networks where nodes have structure

Frame with a number of slots (age, height, ...) Each slot stores specific item of information

When agent faces a new situation Slots can be filled in (value may be another frame) Filling in may trigger actions May trigger retrieval of other frames

Inheritance of properties between frames Very similar to objects in OOP

Example: Frame Representation

Flexibility in frames Slots in a frame can contain

Information for choosing a frame in a situation Relationships between this and other frames Procedures to carry out after various slots filled Default information to use where input is missing Blank slots: left blank unless required for a task Other frames, which gives a hierarchy

Can also be expressed in first order logic

How frames are organised A frame system is a hierarchy of frames

Each frame has: a name slots: these are the properties of the entity that

has the name, and they have values A particular value may be:

a default value an inherited value from a higher frame a procedure, called a daemon, to find a value a specific value, which might represent an

exception

How frames are organised In the higher levels of the frame hierarchy,

typical knowledge about the class is stored The value in a slot may be a range or a condition

In the lower levels, the value in a slot may be a specific value, to overwrite the value which would otherwise be inherited from a higher frame

How frames are organised An instance of an object is joined to its class by

an 'instance_of' relationship

A class is joined to its superclass by a 'subclass_of' relationship

Frames may contain both procedural and declarative knowledge Slot values normally amount to declarative

knowledge, but a daemon is in effect a small program So a slot with a daemon in it amounts to procedural

knowledge

How frames are organised Note that a frames system may allow multiple

inheritance but, if it does so, it must make provision for cases when inherited values conflict

Frames, schemas, prototypes Frames

Concepts as record-like structures Slots – relationships to other concepts,

attributes Fillers – values for slots (other concept or

value)

Schema-theory / Prototypes Some objects are more typical for a certain

class of objects Precise definition for concepts sometimes

not possible, then reference to prototypes

Typical bird is robin – take all “robin-features” as description for class ‘bird’. This forms a prototype.

Take typical chair as prototype. Other chairs are more or less similar to this prototypical chair

The class of all chairs is “fuzzy” since there are no precise or exact boundaries for the class 'chair', i.e. to decide when something is a chair or not.

Frames, schemas, prototypes

Defaults Defaults represent standard values for some

attributes of a concept e.g. the standard number of legs of an elephant

is 4

(Inherited) defaults may be overwritten at lower-level concepts, or for individual concepts

“Clyde” - the famous 3-legged AI-elephant

Problem: If roles, attributes etc. in a concept description can be changed or cancelled, what is the definition of a concept? How can we classify? And reason?

Multiple inheritance and views Multiple inheritance

Sub-concept inherits descriptions from several superconcepts

Possibly conflicting information ( = ambiguity) skeptical reasoners: “don’t know” (no conclusion) credulous reasoners: “whatever” (several

conclusions)

Views Description of concept from different viewpoints Inheritance of multiple, complementing descriptions

e.g. view computer as machine or as equipment

Multiple inheritance - views

Multiple inheritance - ambiguity

Personsubclass

non-pacifist

Nixon

RepublicanQuakerpacifist

subclass

instanceinstance

Frames and procedures Frames often allow slots to contain procedures

So... size slot could contain code to calculate the size of an animal from other data

Sometimes divided into “if-needed” procedures, run when value needed, and “if-added” procedures, run when a value is added (to update rest of data, or inform user)

So... similar, but not quite like OO languages

Frames: some examples The following is an exploration of Minsky's

frames, using simple examples

Note that this is not exactly the way Minsky described frames in his original paper, but it is the way the idea has come to be used in practice

Frames: some examples First a verbal description of some concept is

provided

Then a diagram is shown representing the resulting frame

Next to this is a bit of code which implements this frame in a suitable KR programming language

Frames: some examples We will start with a simple piece of

information: there is a category of things called cars

Given this information, we can start to build a frame:

Name: carName: car Subclass of: thing Subclass of: thing

More information: a car has 4 wheels, is moved by an engine, and runs on petrol or diesel

We can now add three slots to the frame

The last of these has a restriction rather than a specific value

Name: carName: car Subclass of: thing Subclass of: thing

Slots:Slots:

Name: Name: Value: Value: Restrictions:Restrictions:

car subclass_of thing with

wheels: 4,

moved_by: engine,

fuel: [value: unknown, type: [petrol,diesel]]

wheelswheels 4 4

moved bymoved by engine engine

fuelfuel ? ? petrol or dieselpetrol or diesel

“a car has 4 wheels, is moved by an engine, and runs on petrol or diesel”

More information: there is a particular type of car called a VW, manufactured in Germany

We can add a second frame to our system, with one slot

We don’t need to repeat the slots and values in the previous frame: they will be inherited

Name: VWName: VW Subclass of: car Subclass of: car

Slots:Slots:

Name: Name: Value: Value: Restrictions:Restrictions:

‘VW’ subclass_of car with

made_in: ‘Germany’

made inmade in Germany Germany

“there is a particular type of car called a VW, manufactured in Germany”

More information: there is a particular type of VW called a Golf, which has a sunroof

We can add a third frame to our system, with one slot

Once again, we don’t repeat the slots in the previous frames, because they will be inherited

Name: GolfName: Golf Subclass of: VW Subclass of: VW

Slots:Slots:

Name: Name: Value: Value: Restrictions:Restrictions:

‘Golf’ subclass_of VW with

top: sunroof

toptop sunroof sunroof

“there is a particular type of VW called a Golf, which has a sunroof”

More information: there is a particular type of Golf called a TDi, which runs on diesel. A TDi has 4 cylinders, and an engine capacity of 1.8 litres

We can add a fourth frame to our system, with three slots. One of the slots (fuel) was already in the system, but appears here because it now has a specific value rather than a restriction

Name: TDiName: TDi Subclass of: Golf Subclass of: Golf

Slots:Slots:

Name: Name: Value: Value: Restrictions:Restrictions:

‘TDi’ subclass_of ‘Golf’ with

fuel: diesel,

engine_capacity: 1.8,

cylinders: 4

fuelfuel diesel diesel

engineengine capacitycapacity 1.8 litres 1.8 litres

cylinderscylinders 4 4

“there is a particular type of Golf called a TDi, which runs on diesel, has 4 cylinders, and has a 1.8

litre engine”

More information: my car, called C637SRK, is a Golf TDi. It hasn’t got a sunroof.

We can add a fifth frame to our system, with two slots. Unlike all the previous frames, this one is an instance frame. One of the slots (top) was already in the system, but appears here because the value contradicts (overwrites) the value which would otherwise be inherited

Name: C637SRKName: C637SRK Instance of: TDi Instance of: TDi

Slots:Slots:

Name: Name: Value: Value: Restrictions:Restrictions:

‘C637SRK’ instance_of ‘TDi’ with

owner: me,

top:

no_sun_roof

ownerowner me me

toptop no sunroof no sunroof

“There is a car called C637SRK which is an instance of a Golf TDi etc”

More information: to calculate a car’s cylinder size, you divide the total engine capacity by the number of cylinders

We can now add another slot to the car frame: a procedure which discovers the information

required, if the user asks what the value in the slot is

Name: carName: car Subclass of: thing Subclass of: thing

Slots:Slots:

Name: Name: Value: Value: Restrictions:Restrictions:

car subclass_of thing withwheels: 4,

moved_by: engine,

fuel: [value: unknown, type: [petrol,diesel]],

cylinder_size: [value: unknown, access_rule: (if the engine_capacity of ?self is E & the cylinders of ?self is C & Ans := E/C then make_value Ans)]

wheelswheels 4 4moved bymoved by engine enginefuelfuel ? ? petrol or dieselpetrol or dieselcylinder sizecylinder size ? ? find total enginefind total engine

capacity, findcapacity, find no.of cylinders,no.of cylinders,

divide first bydivide first bysecondsecond

“to calculate a car’s cylinder size, you divide the total engine capacity by the number of

cylinders”

Benefits of Frames Makes programming easier by grouping

related knowledge

Easily understood by non-developers

Expressive power

Easy to set up slots for new properties and relations

Easy to include default information and detect missing values

Drawbacks of Frames No standards (slot-filler values)

More of a general methodology than a specific representation: Frame for a classroom will be different for a

professor and for a maintenance worker

No associated reasoning/inference mechanisms

Semantic networks (etc) and logic How do we precisely define the semantics of a

frame system or semantic network?

Modern trend is to have special knowledge representation languages which look a bit like frames to users, but which: Use logic to define what relations mean Don’t provide the full power of predicate logic, but

a subset that allows efficient inference (May not want more than inheritance)

Other varieties of structured object Knowledge representation researchers -

particularly Roger Schank and his associates - devised some interesting variations on the theme of structured objects

In particular, they invented the idea of scripts (1973)

A script is a description of a class of events in terms of contexts, participants, and sub-events

Scripts Rather similar to frames: uses inheritance

and slots; describes stereotypical knowledge (i.e. if the system isn't told some detail of what's

going on, it assumes the "default" information is true)

but concerned with events

Scripts Why represent knowledge in this way?

Because real-world events follow stereotyped patterns Human beings use previous experience to understand

verbal accounts; computers can use scripts instead

Because people, when relating events, leave large amounts of assumed detail out of their accounts People don't find it easy to converse with a system that

can't fill in missing conversational detail

Scripts Scripts predict unobserved events

Scripts can build a coherent account from disjointed observations

Scripts Commercial applications of script-like structured

objects: work on the basis that a conversation between two people on a pre-defined subject will follow a predictable course

Certain items of information need to be exchanged. Others can be left unsaid (because both people know

what the usual answer would be, or can deduce it from what's been said already), unless (on this occasion) it's an unusual answer

Scripts This sort of knowledge representation has

been used in intelligent front-ends, for systems whose users are not computer specialists

It has been employed in story-understanding and news-report-understanding systems

Non-monotonic logic Once true (or false) does not mean always true (or

false)

As information arrives, truth values can change (Penelope is a bird, penguin, magic penguin)

Implementations Circumscription

Bird(x) and not abnormal(x) -> flies(x) We can assume not abnormal(x) unless we know abnormal(x)

Default logic “x is true given x does not conflict with anything we already

know”

Truth maintenance systems These systems allow truth values to be

changed during reasoning (belief revision)

When we retract a fact, we must also retract any other fact that was derived from it Penelope is a bird (can fly) Penelope is a penguin (cannot fly) Penelope is magical (can fly) Retract (Penelope is magical) (cannot fly) Retract (Penelope is a penguin) (can fly)

Types of TMS Justification based TMS

For each fact, track its justification (facts and rules from which it was derived)

When a fact is retracted, retract all facts that have justifications leading back to that fact, unless they have independent justifications

Assumption based TMS Represent all possible states simultaneously When a fact is retracted, change state sets For each fact, use list of assumptions that make that fact

true; each world state is a set of assumptions

Structured objects: final comments A KR system with property inheritance should

make a distinction between essential properties ('universal truths') and accidental properties Some don't: some allow unrestrained overwriting

of inherited properties It's possible to generate incoherent structures in

any of these systems It's particularly easy when multiple inheritance is

involved

Structured objects: final comments At best, structured objects provide data &

control structures which are more flexible than those in conventional languages, and so more suited to simulating human reasoning

Conclusion Issues in KR

Logical representations FOPL Will focus on this next week

“Non-logical” Semantic networks Frames Scripts ...

KBSs using structured objects Two examples of KBSs using structured

objects for knowledge representation

Explorer Explorer is a natural-language interface for a

database relating to oil-wells: Contains geological knowledge, organised as

structured objects Interfaced to a graphics package that can draw

oil-exploration maps

The geologist can converse with the program in unconstrained natural language, and in geological jargon

Bank customer advisory system Bank customer advisory system:

Advises customer on opening a bank account, based on customer's needs/characteristics. This is a task that can consume a lot of the bank staff's time

Deduces customer's intended meaning Does not annoy customer by asking for every

detail; uses its knowledge about people to deduce what the answers must be

The CYC Project A very large scale commercial research

project designed to represent a large body of common-sense knowledge

Headed by Lenat and Guha, and based in Austin, Texas

Has been making steady progress since 1984

The CYC Project It now ‘knows’ a huge collection of fragments

of real-world knowledge such as: Mothers are older than their children You have to be awake to eat You can usually know people’s noses, but not their

hearts If you cut a lump of peanut butter in half, each

half is a lump of peanut butter, but if you cut a table in half, neither half is a table

The CYC Project The ultimate objective is to give it enough

knowledge to understand ordinary books, so that it can read them and expand its own knowledge

So far, it’s got to a stage where, when asked to find photos of “risky activities”, it located photos of people climbing mountains and doing white-water rafting