timm@runxtsa.runx.oz.au (Tim Menzies) (11/28/90)
Are inheritance hierarchies a good way you represent
knowlege?
I recently presented a paper (by proxy, thanx Alan) to
the 1990 Australian Joint Artificial Intelligence
conference. In that, I observed that in the three years
that I have been using OO tools for expert systems, I have
**never** shown an object hierarchy to a expert. My own
hierarchies were so intiricate, I ended up hiding them
behind interfaces that presented some abstarcted/filtered
view of networks of instances to the experts.
One of the comments after the presentation was that
hierachies **MUST BE** a good way of representing knowlege
because of the all the real world knowledge represented as
hierarchies. For example, in biology, the classification of
plants and animals are all presented hierarchically. (I
don't agree with this argument BTW, see below).
Now, we could debate this issue, or we subject it to an
emperical test. Could anyone who has actually built a
non-trivial object system email me (or the net) and let me
know how much of the explicit business/expert knowledge
was clearly defined in an inheritance hierarchy? If there is
enough interest in this, I'll post a reply.
As to the above argument re plant/animal classification:
Just what are those hierarchies used for? Actually expert
processing of significant biologically problems? Or only as
a learning tool for new biologists? (I suspect the
latter.)
My own experience has been that in order to make an
inheritance hierarchy useful (in some non-trivial sense),
then we need to surround/bury the hierarchy in such an
intricate architecture that the significance/usefulness of
the hierarchy reduces to zero. Hierarchies, I have found
are useful for storing programmer knowledge, but not non-
programmer expert knowledge.
--
_--_|\ Tim Menzies (timm@runxtsa.oz) "Two years ago, I couldn't even
/ \ HiSoft Expert Systems Group, spell 'knowledge engineer'.
\_.--._/ 2-6 Orion Rd Lane Cove, NSW, 2d066 Now I r 1."
v 02 9297729(voice),61 2 4280200(fax) John McDermontegdorf@zaphod.lanl.gov (Skip Egdorf) (12/03/90)
In article <2586@runxtsa.runx.oz.au> timm@runxtsa.runx.oz.au (Tim Menzies) writes: > > Are inheritance hierarchies a good way you represent > knowlege? > ... > One of the comments after the presentation was that > hierachies **MUST BE** a good way of representing knowlege > because of the all the real world knowledge represented as > hierarchies. > ... > My own experience has been that in order to make an > inheritance hierarchy useful (in some non-trivial sense), > then we need to surround/bury the hierarchy in such an > intricate architecture that the significance/usefulness of > the hierarchy reduces to zero. Hierarchies, I have found > are useful for storing programmer knowledge, but not non- > programmer expert knowledge. Your last sentence goes to the heart of the matter. An object-oriented system is a design or a programming level abstraction. At this level it is the (current) finest known engineering paradigm for construction of software systems available. Its purpose is precisely to store programmer knowledge. It serves this purpose very well. An expert system stores knowledge of a different type dealing with a very different realm. This is true even if the expert system deals with the realm of programming as would (e.g.) a programmers assistant. The expert system is a user-level abstraction dealing with user-level concepts. While some (as you point out, simple) hierarchies exist that capture some bits of knowledge, real knowledge-based systems require more complex representations than are available in object-oriented programming systems. While object-oriented programming systems can be used to capture such simple heirarchies, such use in real applications does not allow the capture of the more complex relationships. The object-oriented programming system captures the lower-level details of the construction of the higher-level knowledge-representation system (when properly used as am implementation tool.) The expert system deals with knowledge representation at the level of meeting the user requirements for which the expert system is designed. The object-oriented system captures knowledge dealing with the implementation and design of the first. I expect that your question stems from an inappropriate mixture of the two unrelated concepts. Skip Egdorf hwe@lanl.gov
ksand@Apple.COM (Kent Sandvik) (12/03/90)
In article <EGDORF.90Dec2171044@zaphod.lanl.gov> egdorf@zaphod.lanl.gov (Skip Egdorf) writes: >In article <2586@runxtsa.runx.oz.au> timm@runxtsa.runx.oz.au (Tim Menzies) writes: >> >> Are inheritance hierarchies a good way you represent >> knowlege? >While some (as you point out, simple) hierarchies exist that capture some >bits of knowledge, real knowledge-based systems require more complex >representations than are available in object-oriented programming systems. >While object-oriented programming systems can be used to capture such simple >heirarchies, such use in real applications does not allow the capture of >the more complex relationships. The object-oriented programming system >captures the lower-level details of the construction of the higher-level >knowledge-representation system (when properly used as am implementation >tool.) The objects are quite cabable of knowing knowledge about their internal data and relationships between. But it is true that the OOPS paradigm is not very well suitable for cross-knowledge. If we look at multiple inheritance and knowledge inheritance, we still have problems with definitions of relationships between objects. Has anyone looked at providing meta-information in meta-objects that have built-in methods for knowledge requisition, for example having Prolog methods and fields embedded in meta-objects? regards, Kent Sandvik -- Kent Sandvik, Apple Computer Inc, Developer Technical Support NET:ksand@apple.com, AppleLink: KSAND Zippy says: "With C++ we now do have the possibilities to inherit dangling pointer problems"
naren@cs.UAlberta.CA (Narendra Ravi) (12/03/90)
ksand@Apple.COM (Kent Sandvik) writes: >In article <EGDORF.90Dec2171044@zaphod.lanl.gov> egdorf@zaphod.lanl.gov (Skip Egdorf) writes: >>In article <2586@runxtsa.runx.oz.au> timm@runxtsa.runx.oz.au (Tim Menzies) writes: >>> >>> Are inheritance hierarchies a good way you represent >>> knowlege? >>While some (as you point out, simple) hierarchies exist that capture some >>bits of knowledge, real knowledge-based systems require more complex >>representations than are available in object-oriented programming systems. >>While object-oriented programming systems can be used to capture such simple >>heirarchies, such use in real applications does not allow the capture of >>the more complex relationships. The object-oriented programming system >>captures the lower-level details of the construction of the higher-level >>knowledge-representation system (when properly used as am implementation >>tool.) Not always true. See below. >The objects are quite cabable of knowing knowledge about their internal >data and relationships between. But it is true that the OOPS paradigm >is not very well suitable for cross-knowledge. No, Not just the OOPS paradigm, but coupled with deduction it definitely is a good tool. See below. >If we look at multiple inheritance and knowledge inheritance, we still >have problems with definitions of relationships between objects. Yes, but addition of epistemic knowledge would definitely help. >Has anyone looked at providing meta-information in meta-objects that >have built-in methods for knowledge requisition, for example having >Prolog methods and fields embedded in meta-objects? The people working on the CYC project at MCC should be able to answer this question. The articles they publish definitely give an indication that they use inheritance hierarchies. But what exactly they use to enhance the usability/maintenance of information (even) at the meta-level is not very clear. They do talk of special inference procedures to manage large bodies of (non-programmer) knowledge. Here is a small quote ... it is likely that the new constructs (to CycL, the representation language) are going to be incrementally added to improve CycL's inferencing. ... such special purpose constructs (templates for classification, inheritance, special-purpose inference mechanisms, and so on) is likely to prove bothersome to other programs that use Cyc. The representation provides (according to the authors) a basis of epistemological and default reasoning. The paper I am referring to is the Midterm report on Cyc. Cyc: A Midterm Report: R. V. Guha, D. B. Lenat AI Magazine, Fall 1990. But this is not where actual technology is discussed. One gets only a flavor for what is happening. I have said enough. Now other enlightened people can provide a better analysis of the issue. >regards, >Kent Sandvik Cheers, Naren. -- ======================================================================= * Narendra Ravi * 615, General Services Building, * * Email : naren@cs.ualberta.ca * Department of Computing Science * * : naren@alberta.UUCP * University of Alberta * * Tel : (403) 492-3520 (Off) * Edmonton, Alberta, CANADA T6G 2H1 * =======================================================================
marick@cs.uiuc.edu (Brian Marick) (12/03/90)
timm@runxtsa.runx.oz.au (Tim Menzies) writes: >As to the above argument re plant/animal classification: >Just what are those hierarchies used for? Actually expert >processing of significant biologically problems? Or only as >a learning tool for new biologists? (I suspect the >latter.) In my (very limited) understanding, biological taxonomies are not "single inheritance". They're closer to multiple inheritance, but I'm not sure that's a good fit, either. They are "polythetic", which means: 1. There are a number of relevant properties. 2. Each property is possessed by large numbers of individuals. 3. No property is possessed by every individual. This means that there is no abstract archetype. The search for one can lead to an explosion of categories, one for each possible (or noteworthy) combination of properties, with a complicated and seemingly arbitrary inclusion structure (as you pointed out). Here's a reference I had lying around: Rodney Needham. 'Polythetic Classification: Convergence and Consequences'. Man, Vol. 10, No. 3, September, 1975, pp. 349-369. Brian Marick Motorola @ University of Illinois marick@cs.uiuc.edu, uiucdcs!marick
eanv20@castle.ed.ac.uk (John Woods) (12/06/90)
There are a number of ways of representing organisms in hierarchies, but
must biologically reasonable organisations reflect the perceived truths
about evolutionary history, the currently most-widely accepted view
still being that all organisms spring from just one ancestral group.
...Johnburdick@mentor.cc.purdue.edu (Bill Burdick) (12/10/90)
If you look at James Allen's book on natural language processing (I
think it's called _Understanding Natural Language_, but I'm not sure),
there is a section on understanding by meaning (I think it's chapters
7 - 10). In that section, he uses a semantic network to model the
meanings of words. This network is actually an inheritance graph (a
directed, acyclic graph) which uses multiple inheritance.
Inheritance graphs are also known as generalization hierarchies; as
you go up the graph, you get more general. Inheritance is useful in
modelling things (or parts of things) which can be expressed in
different levels of generality.
No human has perfectly organized knowledge (Mansky says "the brain is
a kludge"). To get a good expert system going, you'll probably not
only need rules, but a model of system's domain. The model will
probably end up being OO and the rules will probably end up being a
rule-base (not OO). The meaning section in Allen's book also follow's
this pattern -- the meanings of words are modeled by a semantic
network where the nodes contain information about which rules to
activate and deactivate (actually the rules form a full {not context
free} grammar).
So you'll probably end up needing inheritance (although you may not
represent it explicitly) for an expert system, but that's not the
whole thing.
-- Bill Burdick
burdick@mentor.cc.purdue.edu