Hi Bill
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/.
Thanks - this looks very close to our own problematics.
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.
Yes I agree; I am in a situation where I am working with an
ontology-based semantic repository that I would like to populate. So my
starting point is really the ontology, and not the text corpus or the
pure text-mining problematics (and perhaps this is a slightly different
point of view than most of the people using UIMA ?). So I naturally
tend to ask myself "How can I simplify the transitioning of UIMA or
non-UIMA based text-mining tools to an OWL-based semantic repository ?".
This is why trying to convert an existing off-the-shelf OWL ontology to
a UIMA type system would seem like something natural (not the other way
around though, as you said). However, I want something that can adapt
to any given ontology, so I ended up defining a generic UIMA type
system (like redefining the RDF metamodel with Entities, Relations,
Occurrences, etc.). I see that I came to the same idea of model as the
one you describe in your paper, so this conforted my first ideas :-)
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.
Florence Amardeilh, a PhD student has worked on the same problematic
here at Mondeca;
You can find an english abstract of her work at :
http://mondeca.wordpress.com/2007/04/20/10-mai-2007-soutenance-de-these-%e2%80%93-web-semantique-et-informatique-linguistique-propositions-methodologiques-et-realisation-d%e2%80%99une-plateforme-logicielle/
And an english paper at :
http://halshs.archives-ouvertes.fr/docs/00/11/52/55/PDF/amardeilh_ESWC06.pdf
Best,
Thomas
--
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]>
|
