Hi. A couple notes of clarification: KITE (which is part of the SUKI
suite of tools) was built to interoperate with UIMA from the beginning,
but many aspects of it (and other SUKI components) are not as tightly
integrated with UIMA as we would like. For example, much of it was
built before the UIMA API's for custom flow-controllers had been
exposed, so it has its own mechanisms for controlling flow that are
inconsistent with UIMA's approach. We would probably want to address
these issues before we would release these components as open source.
Even if we were not going to do that, we would at least need to deal
with documentation, packaging, code review, etc. before we could issue a
release. We drew up a project plan for doing so, but unfortunately our
research group has run into other urgent priorities, so I would not
expect us to complete that any time in the foreseeable future. The
direct link for papers describing SUKI (including KITE) and related
issues is http://www.research.ibm.com/UIMA/SUKI/.
In another message in this thread (q.v.) Adam discusses converting
between OWL and UIMA type systems via ECore and the IODT toolkit. I
have tried this, and it can be done. However, in practice it tends to
be much less useful than you might think. The design criterion for UIMA
type systems and OWL ontologies tend to be very different. UIMA type
systems are essentially object-oriented programming data structured
designed for convenient creation and manipulation; in addition, UIMA
types are generally expected to be metadata about a specific artifact
such as a text document. In contrast, OWL ontologies are intended to
support reasoning, usually about "the real world" rather than some
unstructured source that depicts the world. The ways people go about
designing such things tends to be very different. Thus if you take an
OWL ontology that was written to be an OWL ontology and automatically
translate it into a UIMA type system, you generally get a type-system
that is very clumsy and inefficient to populate and manipulate. In
addition (as noted in the original message) OWL is much more expressive
in many respects (e.g., multiple inheritance, inferred type membership,
etc.), so many of the interesting aspects of the OWL ontology gets
lost. Converting the other direction also rarely seems useful; if you
take a type system from a typical complex UIMA application and convert
it into OWL, you wind up with something that is generally completely
unsuited to whatever reasoning tasks you would want to do with OWL. Of
course, there may be advantages to such an automatic conversion despite
these concerns; for example, you mention using Protégé as an editor for
UIMA type systems, which seems like it would work fine as long as you
are careful to avoid the aspects of OWL that won't translate.
In our work on SUKI, we generally went a different way. In particular,
we typically assumed that a UIMA type system and an OWL ontology were
developed separately, typically by different people with different sorts
of goals. Our goal was to be able to create instances encoded in the
OWL ontology from extracted instances encoded in the UIMA type system.
We did this using a combination of both generic and special-purpose
mapping components, integrated using KITE. This allowed us to do
OWL-based reasoning over the results of our UIMA-based information
extraction. Some discussion of this process is found in:
Towards Knowledge Acquisition from Information Extraction.
Christopher Welty and J. William Murdock. Proceedings of the 5th
International Semantic Web Conference (ISWC'06), Athens, GA. 2006.
A link to that paper is available on the SUKI page, linked above.
--
Bill Murdock, PhD
UIMA User (but not a UIMA developer or official spokesperson)
IBM Watson Research Center
19 Skyline Dr., Hawthorne, NY 10532 USA
http://bill.murdocks.org
[EMAIL PROTECTED] wrote:
Thomas,
Check out these projects from IBM Research: http://bill.murdocks.org
Especially look at the KITE and SUKI projects.
The was talk at one point about re-implementing these on top of UIMA and
open-sourcing them, but that was over a year ago and I haven't heard about any
progress toward that.
Greg Holmberg
-------------- Original message ----------------------
From: Thomas Francart <[EMAIL PROTECTED]>
Defining a type system in UIMA looks very much like defining an (simple) OWL
ontology (http://www.w3.org/TR/owl-ref/). I was just wondering if there have
been any effort into developping something that could make a connection between
a UIMA type system and an OWL ontology ? (like generating OWL from a type
system or vice versa)
------------------------------------------------------------------------
Subject:
UIMA type systems and OWL ontologies
From:
Thomas Francart <[EMAIL PROTECTED]>
Date:
Fri, 21 Sep 2007 16:20:33 +0000
To:
[email protected]
To:
[email protected]
Hi
Defining a type system in UIMA looks very much like defining an
(simple) OWL ontology (http://www.w3.org/TR/owl-ref/). I was just
wondering if there have been any effort into developping something
that could make a connection between a UIMA type system and an OWL
ontology ? (like generating OWL from a type system or vice versa)
I can see a couple of advantages to this :
- Users defining their type systems could instead define an
ontology using existing visual editors like protégé or swoop
- OWL adds a lot more constraints than a UIMA type system - these
constraints need be completely implemented in UIMA, but at least some
simple ones, like cardinalities
- OWL uses RDF datatypes (String, booleans, times, etc.) onto
which UIMA could build, instead of redefining its own datatypes
- etc.
Thoughts ? comments ?
Cheers,
Thomas
--
Thomas Francart
Mondeca
3, cité Nollez 75018 Paris France
Tel: +33 (0)1 44 92 35 04 - Fax: +33 (0)1 44 92 02 59
Blog: mondeca.wordpress.com <http://mondeca.wordpress.com>
Web: www.mondeca.com <http://www.mondeca.com>
Mail: [EMAIL PROTECTED] <mailto:[EMAIL PROTECTED]>
