It seems that Horn clauses are sufficient to define the IsConstituent() clauses. An important task is to estimate how efficient pattern recognition will be under the class of Horn clauses.| Home | Table of Contents |
General Intelligence :
John hits Mary.
Mary slaps John.
John punches Mary.
Mary kicks John.
etc etc...
The goal is to recognize: John and Mary are fighting.
So we have the following facts in working memory:
hit(john,mary,t1)
slap(mary,john,t2)
punch(john,mary,t3)
kick(mary,john,t4)
etc etc...
The recognition of "fight" will create an abstract individual (see reification) equivalent to fight(x,y):
isa_Fight(fight1)
with(fight1,x)
with(fight1,y)
(we can also use typed logic and say exists fight1:fight).
The recognizer should add the fact fight(john,mary) to the Working Memory, but this is not the whole story. The special thing about pattern recognition (as opposed to inference) is that we need to collect (ie, exhaustively search for) all the constituents of a pattern. For example, the fighting of John and Mary, as a pattern, consists of John hitting Mary at t1, Mary slapping John at t2, etc. We refer to "punch", "slap", etc as "hurt". So these additional facts will be added to Working Memory:
fight(fight1)
isConstituent(fight1,hurt1)
isConstituent(fight1,hurt2)
etc...
The rule for recognizing fight() works via recognizing what could be the constituents of fight1:
isConstituent(Fight,H1) :- isa_Hurt(H1) ^ from(H1,X) ^ to(H1,Y) ^ isConstituent(Fight,H2) ^ isa_Hurt(H2) ^ from(H2,Y) ^ to(H2,X)
which literally means that hurt(X,Y) is a constituent of Fight if hurt(Y,X) is also. This definition is recursive, but the recursion can be resolved in 1 step, and is actually the fastest way to recognize the conjunction of hurt(X,Y) and hurt(Y,X).
Note that the act of "hurting" is reified as h1 and h2 (see reification). Also, there should be a rule stating that "hurting" includes "punching", "slapping", etc; see the explanation for hurt() in the symbol grounding section.
A production rule consists of a head and a body. The body may be separate from the head and it specifies how constituents are recognized by the pattern. The is is slightly more complex than the single-line production rules of common expert systems.
Recall that in predicate logic, there are 3 types of entities: objects, properties, and relations. Each of these may be the head of a pattern:
It seems that Horn clauses are sufficient to define the IsConstituent() clauses. An important task is to estimate how efficient pattern recognition will be under the class of Horn clauses.
{ To do: there should be methods to derive fuzzy / probabilistic truth values associated with production rules. }
People may doubt if all concepts can be defined with relatively simple logic formulas. The problem of representing all kinds of concepts is a long-standing problem in cognitive psychology known as categorization, with 2 contending views known as the similarity-based and explanation-based.
In the similarity-based / instance-based view the elements of a category (such as "bottles" or "faces") are related to each other due to similarities that perhaps can be measured by some distance matrics in some conceptual space. In the explanation-based / rule-based view categorization is based on systematic rules (eg "all faces have exactly 2 eyes").
Our approach is similar to the 2-tier theory proposed by [Michalski 1989] in which concepts consist of both "base concept representation" (instances) and "inferential concept interpretation" (rules).
Firstly, a concept is represented by a number of typical instances. For example, to "hurt" someone includes:
Hurt(x,y) :- Hit(x,y) | Slap(x,y) | Punch(x,y) | Stab(x,y) | Kick(x,y) | etc...
But a concept cannot be defined by exhaustively enumerating all its instances, so the definition has to be complemented by an explanatory rule. For example, a novel way of hurting someone may be to use banana skin to cause someone to slip and fall. So we need a rule like "to hurt y means to do something that causes damage to y".
The 2-tier approach may seem to be eclectic and redundant, but in fact is necessary. The purely instance-based approach cannot deal with instances that are novel or drastically deviant from the norm; The purely rule-based approach is unfeasible because it will result in a web of circular definitions (eg to hurt is to cause harm, to harm means to damage, to damage means to hurt, etc).
It is not necessary for all high-level concepts to be defined directly down to lowest-level features, but at least some concepts must be defined this way, otherwise the set of high-level concepts would be totally disconnected from perceptual grounding, resulting in a "floating" web of circular definitions.
The 2-tier approach in the last section is a solution to the symbol-grounding problem because it provides a redundancy of definitions, some concrete (ie, grounded by perception) and some abstract (ie, defined using other high-level concepts).
For example, we have a list of concrete ways to "hurt" someone:
Hurt(x,y) :- Hit(x,y) | Slap(x,y) | Punch(x,y) | Stab(x,y) | Kick(x,y) | etc...
And we also have an abstract rule like "if x causes z to happen, and z damages y":
Hurt(x,y) :- Cause(x,z) ^ Damage(z,y)
Then we can hope to infer something like "John causes Mary to slip and fall, and falling damages Mary's butt" because, again, other abstract terms like Damage() may have perceptual grounding. In short, perceptual grounding needs only be partial.
You may provide some instant feedback with this form:
[Michalski 1989] Two-tiered concept meaning, inferential matching, and conceptual cohesiveness. In Vosniadou & Ortony eds, Similarity and analogical reasoning, p122-145. Cambridge University Press, New York.
| Home | Table of Contents |
19/Sep/2006 (C) GIRG [ Notice about intellectual property on this page ]