[
Lists Home |
Date Index |
Thread Index
]
Hi
If we say that actually Google or Teoma make some statements about web
resources and that these statements can be expressed by RDF statements, then
can we say that, in fact Google or Teoma are using prototype based ontology?
As we know, the object modeling world proposes two ways to create
ontologies:
A) Formal
b) Prototype based.
The former is incorporated into object oriented languages like java,
smalltalk or C++
The latter is incorporated into prototype instance based languages like
JavaScript (ECMA script) or Self.
In the last years, work from Yoder about Adaptive Object models helped make
a transition from static models into dynamic ones. The main purpose being to
make the system more "agile", allowing to refine its internal logic as its
implementers learns about the world. Thus, formal models can evolve and
follow the implementer's learning curve. Speaking of learning curve, how
many people are graduating with perfect "A" during their college years? Have
you ever considered that this gives you a clue about the gap between a
certain model and people having to learn it or implement it? This is
especially through is the knowledge has never been codified with modeling
languages. The process to translate the knowledge from textual or tacit
knowledge could is not that obvious and may be error prone. This is why,
recently the object world tried to break the static formal models and make
then adaptive.
Question: is the web agile or static? Is it possible to create a perfect
model? If not, how can it be changed? This leads to the problem of version.
I tried to see if an OWL model includes a versioning mechanism but wasn't
able to find it. Maybe I have not looked at the right place. Where is it
specified?
Note: John Sowa proposed the following definition for a prototype based
ontology
prototype-based ontology.
A terminological ontology whose categories are distinguished by typical
instances or prototypes rather than by axioms and definitions in logic. For
every category c in a prototype-based ontology, there must be a prototype p
and a measure of semantic distance d(x,y,c), which computes the
dissimilarity between two entities x and y when they are considered
instances of c. Then an entity x can classified by the following recursive
procedure:
Suppose that x has already been classified as an instance of some category
c, which has subcategories s1,...,sn.
For each subcategory si with prototype pi, measure the semantic distance
d(x, pi , c).
If d(x, pi , c) has a unique minimum value for some subcategory si, then
classify x as an instance of si, and call the procedure recursively to
determine whether x can be further classified by some subcategory of si.
If c has no subcategories or if d(x, pi , c) has no unique minimum for any
si, then the classification procedure stops with x as an instance of c,
since no finer classification is possible with the given selection of
prototypes.
As an example, a black cat and an orange cat would be considered very
similar as instances of the category Animal, since their common catlike
properties would be the most significant for distinguishing them from other
kinds of animals. But in the category Cat, they would share their catlike
properties with all the other kinds of cats, and the difference in color
would be more significant. In the category BlackEntity, color would be the
most relevant property, and the black cat would be closer to a crow or a
lump of coal than to the orange cat. Since prototype-based ontologies depend
on examples, it is often convenient to derive the semantic distance measure
by a method that learns from examples, such as statistics, cluster analysis,
or neural networks.
|
