EMERCE - 2024 - AMSTERDAM - CROSS-PLATFORM TRACKING WITH GOOGLE ANALYTICS.pptx
semantic.ppt
1. Semantic Networks
• The idea behind a semantic network is that
knowledge is often best understood as a set
of concepts that are related to one another.
The meaning of a concept is defined by its
relationship to other concepts.
• A semantic network consists of a set of
nodes that are connected by labeled arcs.
The nodes represent concepts and the arcs
represent relations between concepts.
2. Common Semantic Relations
There is no standard set of relations for semantic networks, but the
following relations are very common:
INSTANCE: X is an INSTANCE of Y if X is a specific example of
the general concept Y.
Example: Elvis is an INSTANCE of Human
ISA: X ISA Y if X is a subset of the more general concept Y.
Example: sparrow ISA bird
HASPART: X HASPART Y if the concept Y is a part of the concept
X. (Or this can be any other property)
Example: sparrow HASPART tail
3.
4. Inheritance
• Inheritance is a key concept in semantic networks
and can be represented naturally by following ISA
links.
• In general, if concept X has property P, then all
concepts that are a subset of X should also have
property P.
• But exceptions are pervasive in the real world!
• In practice, inherited properties are usually treated as
default values. If a node has a direct link that
contradicts an inherited property, then the default is
overridden.
5. Multiple Inheritance
• Multiple inheritance allows an object to inherit
properties from multiple concepts.
• Multiple inheritance can sometimes allow an
object to inherit conflicting properties.
• Conflicts are potentially unavoidable, so
conflict resolution strategies are needed.
10. Frames
• A frame represents an entity as a set of slots
(attributes) and associated values.
• Each slot may have constraints that describe
legal values that the slot can take.
• A frame can represent a specific entity, or a
general concept.
• Frames are implicitly associated with one
another because the value of a slot can be
another frame.
11. Mammal NBA_BASKETBALL_PLAYER
isa: ANIMAL isa: ADULTMALE
*haspart: HAIR cardinality: 400
*breathes: AIR *height: > 6'
*salary: > $200,000
HUMAN MICHAELJORDAN
isa: MAMMAL instance: NBABASKETBALLPLAYER
cardinality: 6 million height: 6'9''
*haspart: LEGS(2)
ADULTMALE JOHNSTOCKTON
isa: HUMAN instance: NBABASKETBALLPLAYER
cardinality: 2 million height: 6'1''
*gender: male
An asterisk (*) means that the slot can be inherited.
12. Demons
• One of the main advantages of frames is the ability to
include demons to compute slot values. A demon is a
function that computes the value of a slot on demand.
HUMAN
isa: (MAMMAL)
mortal: (yes :inheritable yes)
cardinality: (6 million :inheritable no)
age: (:inheritable yes :demon compute_age)
MARY int Compute_Age (frame)
instance: HUMAN return(today- (query birthday slot));
gender: FEMALE
birthday: 11/04/60
13. Features of Frame Representations
• Frames can support values more naturally
than semantic nets (e.g. the value 25)
• Frames can be easily implemented using
object-oriented programming techniques.
• Demons allow for arbitrary functions to be
embedded in a representation.
• But a price is paid in terms of efficiency,
generality, and modularity!
• Inheritance can be easily controlled.
14. Comparative Issues in Knowledge Representation
• The semantics behind a knowledge representation
model depends on the way that it is used
(implemented). Notation is irrelevant!
Whether a statement is written in logic or as a semantic network
is not important -- what matters is whether the knowledge is
used in the same manner.
• Most knowledge representation models can be made
to be functionally equivalent. It is a useful exercise to
try converting knowledge in one form to another form.
• From a practical perspective, the most important
consideration usually is whether the KR model allows
the knowledge to be encoded and manipulated in a
natural fashion.
15. Expressiveness of Semantic Nets
• Some types of properties are not easily expressed using a
semantic network. For example: negation, disjunction, and
general non-taxonomic knowledge.
• There are specialized ways of dealing with these relationships,
for example partitioned semantic networks and procedural
attachment. But these approaches are ugly and not commonly
used.
• Negation can be handled by having complementary predicates
(e.g., A and NOT A) and using specialized procedures to check
for them. Also very ugly, but easy to do.
• If the lack of expressiveness is acceptable, semantic nets have
several advantages: inheritance is natural and modular, and
semantic nets can be quite efficient.
16. Inheritance
• As we stated before, semantic networks and frames
are often used because inheritance is represented so
naturally.
• But rule based systems can also be used to do
• inheritance! How?
• Semantic networks (and frames) have an
implementation advantage for inheritance because
special-purpose algorithms can be used to follow the
ISA links.
17. Comparative Summary
• Rules are appropriate for some types of
knowledge, but do not easily map to others.
• Semantic nets can easily represent
inheritance and exceptions, but are not well-
suited for representing negation, disjunction,
preferences, conditionals, and cause/effect
relationships.
• Frames allow arbitrary functions (demons)
and typed inheritance. Implementation is a bit
more cumbersome.
18. And just when you thought it was safe to
go out….Networks cont. (implementation)
We see hierarchical organizations in the real world all the time. They
may not be "pure" hierarchies, but they're hierarchical in spirit at
least. It might be easier to think of these things as "networks"
instead of hierarchies. Take for example the common dictionary. At
first glance, it looks like a very linear organization of the words in
our language. But what a dictionary really specifies is a very
complex and somewhat hierarchical map of the relationships
between the words in our language. Here are some sample
definitions:
19. dog: any of a large and varied group of domesticated animals related to
the fox, wolf, and jackal
chihuahua: any of an ancient Mexican breed of very small dog with
large, pointed ears
bird: any of a class of warm-blooded, two-legged, egg-laying
vertebrates with feathers and wings
penguin: any of an order of flight-less birds found in the Southern
Hemisphere, having webbed feet and paddle-like flippers for
swimming and diving
ostrich: a large, swift-running bird of Africa and the Near East; the
largest and most powerful of living birds; it has a long neck, long
legs, two toes on each foot, and small useless wings
canary: a small yellow songbird of the finch family, native to the Canary
Islands
20. Notice that these definitions all relate the thing
being defined to some larger class of things, and
then goes on to try to distinguish that thing
from other similar things. Note also that as the
things being described stray further and further
from what we might think of as being norms or
stereotypes, the definitions get longer and more
detailed. For example, compare the canary (a
stereotypical bird) to an ostrich (an extremely
non-stereotypical bird). When we take the time
to look at the dictionary in this way, we uncover
what is essentially a bunch of pointers from one
word to others.
21. In any case, we can use our high-level data abstraction, the directed
graph, to make these relationships a bit more visual. For example,
from the bird definitions, we can construct the following abstraction:
vertebrate
^
| is-a
has-part
| /------------- wings
/ reproduction
| /--------------- egg-laying
| / body-temp
| /----------------- warm-blooded
bird--< no. of legs
^ ^ ^ ----------------- 2
/ | covering
is-a / | --------------- feathers
/ | movement
color / | ------------- flight
yellow ------canary
size / | is-a is-a
small -----/ | movement
| ostrich---------- run
movement | size
swim ----------penguin --------- big
22. How to represent your networks in LISP
Hey, it's simple. Use an association list.
(defun *database* ()
'((canary (is-a bird)
(color yellow)
(size small))
(penguin (is-a bird)
(movement swim))
(bird (is-a vertebrate)
(has-part wings)
(reproduction egg-laying)
) ))
You'd use the "assoc" function with a key of "canary" to
extract all the information about the "canary" type.
