Conceptual Dependency and

Natural Language Processing

 Project Reminder!
• Just a reminder to get going on your
projects! At this point you should be quite
close to having a program that can play
Billabong using minimax. The full move
generator should certainly be implemented.
The next step should be integrating your
program with the game manager and tuning
your heuristics.
 Conceptual Dependency
• Strong slot/filler structures, chapter 6
• Conceptual Dependency (CD) theory was
developed by Roger Schank at Yale
University in the 1970’s
– Cognitive, psychological approach to AI.
– Most often used in domains where people are
involved (e.g., user modeling, processing of
news stories, etc.)
 CD
• The purpose of CD is a separate “language”
for representing meaning without ambiguity.
– This facilitates drawing inferences.
– If we were writing a language translator
(something people do well) then we’d have
something like
F
r
e
n
ch
G
e
r
ma
n p
a
r
s
i
ng
Co
n
c
e
pt
u
a
l
E
n
g
l
i
shge
n
e
r
a
ti
o
nDe
p
e
n
de
n
cy
S
w
a
hi
l
i
 CD
• You can think of CD as an intermediate
“language”
– Intended to be a deep conceptual representation that has
no ambiguities, that can be used to translate to any
other format.
– Some psychological evidence for such a representation
although not conclusive
– For general language translators, this is much easier
than creating direct mappings from one language to
another.
 Early CD Systems
• SAM - Script Applier Mechanism. SAM could read simple
script-based stories and make inferences. Variations have been
used for reading newspaper stories (FRUMP). More on SAM
later.
• PAM - Plan Application Mechanism. Program capable of
lower-level inference resolution that could apply to situations in
which SAM failed.
• Talespin - A story generation program, given goals and plans,
the characters went through the actions to achieve their goals.
Also addressed emotional, physical states.
• Politics - Political analysis program adopting either a
conservative or liberal viewpoint.
• OpEd - Program capable of reading editorials and analyzing
positions and argument structure.
 What is CD?
• CD is based upon events and actions. Every event
(if applicable) has:
– an ACTOR
– an ACTION performed by the Actor
– an OBJECT that the action performs on
– a DIRECTION in which that action is oriented
• These are represented as slots and fillers. In
English sentences, many of these attributes are left
out.
 Example CD Sentences
1. “Kenrick went to New York.”
The object is missing here; we can fill it in with a rule that
says the actor is the object with the word “go”. Thus, in
CD we would have something like “Kenrick went Kenrick
to New York”

2. “Mary fell.”
In this case, the actor is missing. Mary didn’t really do the
falling, another force, gravity, has acted on Mary and
pushed her in a direction, to the ground.
 Example CD Sentences
3. “John amazed Mary”

If we want to capture the actor, action, object, and

direction this sentence gives part of it. It tells us John is
the actor, and Mary is the recipient.

No action specified;

In CD we’ll represent John did some unknown action

that resulted in a state change within Mary to
amazement.
 Primitive Actions of CD
• Schank and Abelson defined 11 primitive Actions they originally hoped would be
sufficient to represent arbitrary sentences:

• ATRANS: Abstract Transfer, e.g. give

• PTRANS: Physical Transfer of location, e.g. go
• PROPEL: Application of physical force to an object, e.g. push
• MOVE: Movement of a body part by its owner, e.g. hit. Instrumental Act.
• GRASP: Grasping of an object by an actor, e.g. clutch
• INGEST: Ingesting an object by an animal, e.g. eat or drink
• EXPEL: Expulsion of something by an animal, e.g. spit or cry or bleed
• MTRANS: Transfer of mental information, e.g. tell
• MBUILD: Creation of new information, e.g. mental construction or decision
• SPEAK: Production of sounds, e.g. say. Instrumental Act.
• ATTEND: Focusing sense organ toward stimulus, e.g. listen, look.
Instrumental act.
• DO: Any action, used for unknown actions
 Graphical Structure of CD Event
d=direction, R=recipient, state change
tense: o:object I:Instrument
p,f,time... o d,R To
Actor Action I
Object
From New CD Event
optional: R,r,i
R=reason,
r=results, New CD Event
i=intends

Can use these to link together sequences of events. Note that there are
other modifiers, such as k for continuous events. The focus here is not
on the details, but understanding how to make basic constructions of
CD.
 CD Examples
Kenrick went to New York.

o d New York
Kenrick PTRANS KM
 CD Examples
• Mary fell.

o d Ground
Gravity PROPEL Mary
X, X>Ground
 CD Examples
• John amazed Mary.

nD
J
o
h O
r
s
t
a
t
e A
m
a
z
e
d
M
a
r
y
C
o
o
l
 CD Examples
• John saw Mary.

o RC
P
(
Jo
h
n
)
nM
J
o
h T
R
A
NM
Sa
r
y
E
y
e
s
(
Jo
h
n
)
I

o DM
a
r
y
nA
J
o
h T
T
E
N
DEy
e
s

Here, CP is the “Cognitive Processor” of John, or John’s brain.

 CD Examples
• John read a book.
o RC
P
(
Jo
h
n
)
nM
J
o
h T
R
A
NB
So
o
k
IoB
n
f o
o
k
I

o DB
o
o
k
nA
J
o
h T
T
E
N
DEy
e
s
 CD Examples
• John drank milk.

o DM
o
ut
h
(
Jo
hn
)
nI
J
o
h N
G
E
STM
i
l
k
G
l
a
s
s
I

o DM
o
ut
h
(
Jo
hn
)
nP
J
o
h T
R
A
NS
Mi
l
k
 CD Examples
• John shot up heroin.

o D Vein(John)
John INGEST Heroin
Hypo
I

o D Vein(John)
John PROPEL Hypo
 CD Examples
• It is often difficult to keep inferences out of the
representation process.
• Consider the sentence “John beat Mary with a bat”
k o D Mary
John PROPEL Bat
r

state Mary
Phys_Contact
Bat

state Phys_State<X
Mary
Phys_State
>X
 Bat Example
• The resulting condition that Mary was in a lower
physical state is actually a inference. The sentence
alone doesn’t say that Mary was hurt.
• However, it is something we have inferred.
Normally we would leave this out of the CD
representation, and use inference rules to figure
out that Mary was hurt.
– For example, a rule could say that Phys_Contact with a
person and a hard object results in a lower physical
state.
 CD Example
• Mary gave John a bat.

p o R John
Mary ATRANS Bat
Mary
 CD Example
• We can combine CD events as objects, e.g.
“Mary told Kenrick that she gave John a bat.”

p o R Kenrick
Mary MTRANS
Mary

p o R John
Mary ATRANS Bat
Mary
 CD Example
• Wile E. Coyote decided to kill the road
runner.
o DC
P
(W
il
e)
W
i
l
e M
B
UI
LD
L
T
M(
Wil
e)

o
u
tp
ut
obj
ec
t i
npu
t
obj
ec
ts

W
i
l
e D
O L
T
M
r

s
t
at
e P
h
y_
St
at
e(
0)
R
R
P
h
y_
St
at
e>0

There is a tendency to become ad hoc and make up our own definitions; this is ok as long as
we are consistent and can still access the essential primitive actions (same problem in
predicate logic)
 CD a panacea?
• Can you think of something that would be
difficult, inadequate, or impossible to
represent in CD?
 Scripts
• Given a knowledge base in CD, or parsed English
sentences into CD, what can we do with them?
• One application is to couple CD with the notion of
scripts.
– A scripts is a stereotypical sequence of events in a
particular context. These are sequences we have
learned over time. They are similar to scripts for a play
or movie, and contain actors, props, roles, scenes, and
tracks.
 Stereotypical Script
• Consider the stereotypical script of • There are set props:
going to eat at McDonalds (do you – ketchup, mustard dispenser
remember the last time you ate fast – signs
food? How about the time before that? – cash register
Experience may be lost in the
– tables
stereotypicality unless something
unique happened) – drink machine
– Sometimes there are deviations to the • There is a stereotypical
script; e.g. going to the bathroom, or sequence of events:
modifications to the script like getting a – Wait in line
drink before receiving food. People use – Give order
existing scripts or cases to learn new
cases; eventually new cases may – Pay money
become new scripts. – Receive food
• There are set actors: – Sit down
– cleaning guy – Eat
– cashier – Bus own table
– Manager
 Simple Shopping Script
• Actors: Shopper, Clerk
• Objects: Merchandise
• Location: Store

• Sequences (in Lisp format) :

– (PTRANS (Actor ?Shopper) (Object ?Shopper) (To ?Store))
– (PTRANS (Actor ?Shopper) (Object ?Bought) (To ?Shopper))
– (ATRANS (Actor ?Store) (Object ?Bought) (From ?Store) (To ?Shopper))
– (ATRANS (Actor ?Shopper) (Object (Money)) (From ?Shopper) (To
?Store))
– (PTRANS (Actor ?Shopper) (Object ?Shopper) (From ?Store))

• What do these mean in English?

 Shopping Script
• How this helps us? Let’s say we now get an input
story in the form of:
“Jack went to Target. Jack got a DVD player.”
• We can represent this as:
– (PTRANS (Actor (Jack)) (Object (Jack)) (To (Target))
– (PTRANS (Actor (Jack)) (Object (DVD-Player) (To (Jack))
• These CD sequences match the script and would
activate it. The rest of the script is inferred, so we can
now answer questions like:
 Shopping Questions
• “Did Jack pay any money?”
– By just looking up the CD form of the question
– (ATRANS (Actor (Jack)) (Object (Money))
• this matches in the instantiated script, and
our program can spit back “Yes!” and even
give who Jack paid the money to (Target).
• In short, this allows us to do
question/answering on unspecified events.
 Script Disambiguation
• The script also helps us perform disambiguation.
Once we know who the shopper is, we can use
that to fill in the rest. Consider the input
sequence:
– “Jack went to Target. He got a DVD player.”
• With the pronoun ‘he’, one way to disambiguation
who the “he” refers to is through the script, which
would match up the purchaser to the shopper.
 Script Summary
• In short, scripts allow:
– Inference of unspecified events, stereotypical sequences
– Disambiguation of actors and objects
• Internally, scripts are often organized by their
differences.
– For example, consider a general transaction. A more
specific type of transaction could be a restaurant
transaction. More specific types are fast food vs. sit-
down restaurants. If each of these events is stored as a
node, they could be indexed based upon differences.
 Plans / Inference Rules
• In predicate calculus, inference rules were the
major mechanism for making new useful
conclusions.
• We can do the same thing in CD with a pair of CD
statements to make a rule.
– These rules can be used to augment scripts, which will
fail when we come across new situations that don’t
match stereotypical sequences (e.g., what to do if all the
erasers are stolen from the classroom. You probably
don’t have a script for this, although you can certainly
act and make decisions and predictions).
– This is more in line with traditional rule-based systems
and inference.
 PAM
• In Schank’s experimental program PAM, the program
could apply rules that activated low level events or entire
scripts.
• PAM created chains of inferences from various rules that
would follow. When a chain was completed, the resulting
CD was instantiated. For example, a rule could appear
like:
– Grasping an object is a way to perform the plan of taking an object.
• (Instantiation
(Take-Plan (Planner ?X) (Object ?Y))
(Grasp (Actor ?X) (Object ?Y))
 PAM Sample
Taking something that is a book is with the goal of reading it.
(Subgoal
(Read-Plan (Planner ?X) (Object ?Y))
(Take-Plan (Planner ?X) (Object ?Y)))

Using a car is to achieve the goal of being at some location.

(Subgoal
(Use-Vehicle-Plan (Planner ?X) (Object ?Y))
(Goal (Planner ?X) (Objective (Proximity (Actor ?X)
(Location ?Y)))

To use the restaurant script, first be at the location of the restaurant.

(Subgoal
(Use-Restaurant-$ (Planner ?X) (Restaurant ?Y))
(Goal (Planner ?X) (Objective (Proximity (Actor ?X)
(Location ?Y)))
 PAM Sample
If we had a small input story such as:

John picked up the Restaurant Guide. He drove to Humpy’s.

If we had the appropriate rules, we could infer a chain such as:

Picking up the restaurant guide  Take-Plan  Use-Plan  …

Picking up the restaurant guide  Take-Plan  Possess-Plan  …
Picking up the restaurant guide  Take-Plan  Read-Plan  Find-Restaurant-Plan
 Use-Restaurant-$  Proximity Goal at Restaurant
Driving to Humpy’s  Proximity Goal at Restaurant (If we know that Humpy’s
is a restaurant) Match with Restaurant guide.

By linking these sentences together, the system can answer questions like “Why did John
drive to Humpy’s?” (To be at the proximity of the restaurant to use the restaurant plan).
Additionally, we can use the rules to provide disambiguation of variables as with scripts.
 Plans
• In short, plans allow:
– Inference rules to connect CD events
– Disambiguation through variable instantiations
 Parsing into CD
• So far, we have ignored the problem of parsing
input text into CD. We’ve been assuming that we
are already working in the CD domain. However,
a more general system will have to parse input
English text into the CD format.
• One parsing technique is to assign a “packet” to
each word with all of the sense definitions it may
have. The packet watches for other words or
context that came before or after it, and uses this
context to determine the correct meaning of the
word.
CD Parsing Example - Knowledge
(Def-Word Jack
(Assign *cd-form* (Person (Name (Jack)))
*part-of-speech* Noun-Phrase))

Jack just takes the CD format of Person named Jack.

(Def-Word Lobster
(Assign *cd-form* (Lobster)
*part-of-speech* Noun
*type* (Food)))

Definition for lobster is just a noun; we can include semantic information as well.
Ideally this information (e.g. food, lobster) would also be indexed into a semantic
hierarchy so that we have a better idea of what food and lobsters are.
 CD Parsing - Knowledge
(Def-Word Hair
(Assign *cd-form* (hair)
*part-of-speech* Noun
*type* inanimate))
Disambiguates by
Just another sample definition, this time for Hair.
looking ahead to
(Def-Word Had next packet, put on
(Assign *part-of-speech* Verb stack and activated
*subject* *cd-form*
(Next-Packet
(Test (And (Equal *part-of-speech* Noun)
(Equal *type* Food))
(Assign *cd-form* (INGEST (ACTOR *subject*)
(OBJECT *cd-form*))
(Test (And (Equal *part-of-speech* Noun)
(Equal *type* Inanimate))
(Assign *cd-form* (POSS (ACTOR *part-of-speech*)
(OBJECT *cd-form*)))))
 CD Parsing Process
• Parse from left to right
• Retrieve the packet definition for each word
• Assign any variables applicable and put the next-
packet on the stack for examination of future
packets.
• We could also look backwards and see if previous
packets have been examined for disambiguation
purposes; do this by checking to see if we can
execute the top of the stack
 CD Parsing Example
• “Jack had lobster”
Jack: *pos* = Noun-Phrase
*cd-form* = (Person (Name (Jack)))

Had: *pos* = Verb

*subject* = (Person (Name (Jack)))
Wait to see if next packet is a noun or food/inanimate before
proceeding with which definition of Had.

Lobster: *pos* = Noun

*cd-form* = (lobster)
*type* = Food
This activates the first definition of HAD, so the definition
is activated: (INGEST (Actor (Person (Name (Jack))))
(Object (Lobster)))
 Disadvantages of CD Parsing
• The main disadvantage of this approach is the complexity
of the definitions; some words have many definitions, all
of which must be carefully entered by the programmer.
• Additionally, there are many possible objects and other
parts of speech that determine how a word should be
disambiguated, making the process extremely difficult for
large domains or general English.
• Note that people often don’t do this – they will fall for
garden path sentences!
– But people are able to intelligently backtrack and choose another
meaning if necessary (subliminally, there is evidence that more
than one meaning is “activated”).
 Natural Language Processing
• Chapter 13 of the text
• We’ll skip the Prolog parser after all
• Typically, the process of parsing and
understanding languages can be broken up
into a number of different levels
 Levels of NLP
1. Prosody. This deals with the rhythm and intonatation of the language.
2. Phonology. This examines the sounds that are combined to form language.
3. Morphological Analysis. This is the step of analyzing what is a word, what
is punctuation, word tense, suffixes, prefixes, apostrophe, etc.
4. Syntactic Analysis. Essentially determine the part of speech of the words to
see if it is valid. For example, the following sentence could be rejected
from a syntactic analysis: “Tasty the Coon the fast slow green and the yes”
5. Semantic Analysis. Determining the meaning of the words to see if they
make sense. A famous example is “Colorless green ideas sleep furiously”
by Chomsky. This sentence is syntactically correct, but semantically
meaningless.
6. Pragmatic Analysis. Reinterpret events to what they really mean. “Can I
have a coke” at a restaurant is a request, not a yes/no question.
7. Discourse Analysis. A sentence may make sense individually, but not in the
larger context. This phase examines the context of a particular sentence to
see if it makes sense.
“John had lobster”

Syntactic analysis
Q/A, Database Query,
Translator, etc.

NP VP

N V NP

John had N

lobster

Semantic Analysis
Restaurant-Script
(Ptrans (Actor John)
(Ingest (Actor John) …)
(Object Lobster)) Contextual
(Ingest (Actor John)
Analysis
(Object Lobster))
…
 Distinct Phases?
• The best system can ideally go back and forth across
these boundaries in the process of parsing; for example,
performing a semantic analysis can help while doing
syntactic or even morphological processing.
– People also operate this way; we don’t wait for something to
finish parsing before working on semantic analysis. We can
see this by examining the mistakes that people make in
reading “garden path” sentences like:
• The old man the boats.
• The horse raced past the barn fell.
• The player kicked the ball kicked him.
• However, for ease of computing, usually computer
programs separate parsing as these distinct phases.
 Syntactic Parsing
• Most of the work has been done in
Syntactic Parsing. We can use many of the
ideas used in compilers for parsing
computer programs. A common technique
is to define a grammar, and use that
grammar to parse the sentences.
 Syntax Example
Here is a sample grammar for a subset of English:

Context Free Grammar:

SNP VP
SVP
NPDeterminer NP2
NPNP2
NPNP PP
NP2Noun
NP2Adj NP2
PP Prep NP
VPV
VPV NP
VPVP PP

Dictionary:
an : Determiner
arrow: Noun
flies: Noun, Verb
like : Preposition, Verb
time: Adj, Noun, Verb
Recursive Transition Network
 Sample Parse Trees
S

S S VP

NP VP NP VP VP PP

NP2 VP PP NP2 V NP V NP Prep NP

N V Prep NP Adj NP2 like Det NP2 Time NP2 like Det NP2

Time flies like Det NP2 Time N an N N an N

an arrow flies arrow flies arrow

 Syntax + Semantics
• A common approach to construct a semantic
representation from a syntactic parse is to
recursively traverse the syntactic parse tree and
construct a semantic parse tree.
– This is similar to what you saw in CS331 in
constructing a semantic representation for a
programming language from a syntactic parse, but in
our case we'll use our knowledge base of frames to
construct the semantic representation.
 Syntax+Semantics
• Given “The dog bites the man" we might
parse syntactically as
Sentence

Noun_Phrase Verb_Phrase

Article Noun Verb Noun_Phrase

Article Noun

The dog bites the man

 Semantic Knowledge
• Type hierarchy, defined semantic
knowledge
Event Entity State

Act Animate PhysObj

Animal

Bite Dog Person Teeth Like

 Semantic Knowledge
• Frames for each concept
Like Experiencer Animate

Object Entity

Bite Agent Animate

Object Entity part

Instrument Teeth
 Pseudocode for Semantic Parser
Process_Sentence
Noun_Concept  Noun_Phrase()
VP_Concept  Verb_Phrase()
Bind Noun_Concept to agent in VP_Concept

Noun_Phrase Procedure
N  Representation of Noun
If indefinite article and number singular, noun concept is generic
If definite article and number singular, bind marker to noun concept
If number plural, indicate that noun concept is plural

Verb_Phrase Procedure
V  Representation of Verb
If verb has an object
Noun_Concept  Noun_Phrase()
Bind concept for Noun_Concept to object of V
 Semantic Parse Example
1. ()
4. N=dog,singular
10. S = (bite (agent dog) (object man) (instrument (teeth (part dog))))
5. V = ?
6. V = (bite (agent ?A) (object ?O) (instrument (teeth (part ?A))))
2. NP=() 9. V = (bite (agent ?A) (object man) (instrument (teeth (part ?A))))
3. N = dog, singular Sentence

Noun_Phrase Verb_Phrase
7. NP=()
8. N = man, singular

Article Noun Verb Noun_Phrase

Article Noun

The dog bites the man

 Semantic Parse Tree
When the recursive process has finished, we've created the semantic representation of
(Bite (Agent Dog) (Object Man) (Instrument (Teeth (Part Dog)))). This itself could be
construed as a semantic tree:

Action=Bite

instrument
agent object

dog
man teeth

part-of
 Semantic / Discourse Analysis
• Syntactic: left with a number of parse trees
• Semantic analysis : can help us disambiguate which parse tree is
correct.
• Semantic and discourse analysis composes most of the things we
discussed in CD. A way to use the meaning of the words to further
disambiguate what is happening. Semantic analysis can rule out many
interpretations, such as that of “Time flies” being a type of fly, where
Time is an adjective.
• Scripts are one method of discourse analysis; they use the previous
context and previous sentences to interpret new sentences. All steps
together are required for a complete understanding of input text.
However, portions may be used alone to address many problems.
Additionally, often domains can be simplified to a point where a
grammar may be constructed for it and the appropriate understanding
tasks can be applied.
 Demo to Try
• MIT Jupiter system applies analysis from the
phonological level up to discourse, but only in the
small domain of weather around the world.
• Via speech recognition you can ask Jupiter
questions, such as "What is the weather like in
Anchorage?" or "Where is it snowing now?" You
can try it by calling 1-888-573-TALK.
• Note that if you call, your voice will be recorded
and used for future speech recognition research.