W3C home > Mailing lists > Public > public-openannotation@w3.org > March 2013

Re: Best Practices - Semantic Tagging

From: Tim Cook <tim@mlhim.org>
Date: Tue, 5 Mar 2013 09:19:21 -0300
Message-ID: <CA+=OU3VrZV9PXpGpRj7d=uY7mpx68KP+oWvwqMqck2PpoGFsxw@mail.gmail.com>
To: Stian Soiland-Reyes <soiland-reyes@cs.manchester.ac.uk>, Robert Sanderson <azaroth42@gmail.com>
Cc: public-openannotation <public-openannotation@w3.org>
Hi All,
Thanks for the feedback so far.

Frankly I found the syntax that you presented quite confusing.  But
maybe that is why I am engaging this community, to flesh out the best
way to do this in an area where I am not familiar.  As far as
processors not understanding the approach, I agree that there aren't
any in existence today.  Apparently the use case hasn't been presented
before?  However, there is nothing preventing applications from being
able to look up the attribute to get the semantic link. I understand
that solving this may not be within the scope of OA.

Stian: The  xs:annotation/xs:appinfo approach does seem to be the
appropriate way.  Plus, I had missed the fact that appinfo takes a
source attribute.  My only concern with this approach is that it
limits the modeller to one link and "source" doesn't really say
how/what function the referenced link is to be interpreted.  This is
why I had thought to use rdf:/rdfs: attributes.

I may be repeating myself, however the goal is to indicate to users of
the instances what the modeller was taking into consideration when
defining the concept.  The complexType is a restriction of a
complexType from a generic base schema.  Therefore linking to a
specific node in a specific version of "one or more" controlled
vocabularies is important.  This is healthcare data that shall endure
in its meaning even as the science around it changes over time.

I understand your point about going all the way with RDF and in fact,
there is a metadata section of the schema that does just that using
Dublin Core.  Examples: http://www.hkcr.net/CCDs  Maybe that is the
"right way" to do it here as well?  It just seems awfully verbose.


On Tue, Mar 5, 2013 at 8:17 AM, Stian Soiland-Reyes
<soiland-reyes@cs.manchester.ac.uk> wrote:
> My gut feeling is that this should be presented in
> xs:annotation/xs:appinfo, as that is exactly what that structure in
> XSD is intended for.
> But I would not put semi-RDF/XML in there, either go all the way or
> use something else (dcterms?). Thus using rdfs:seeAlso as an attribute
> I would say is inappropriate as it seems to be hinting on being RDF
> when it is not at all.
> Perhaps something like (syntax not checked!):
>   <xs:complexType name="ct-f6c5ea6e-6458-4799-874d-7f3d365d260d"
>                       xml:id="ct-f6c5ea6e-6458-4799-874d-7f3d365d260d">
>     <xs:annotation>
>         <xs:appinfo>
>             <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
>                 <oa:Annotation xmlns:oa="http://www.w3.org/ns/oa#">
>                     <oa:motivatedBy
> rdf:resource="http://www.w3.org/ns/oa#tagging" />
>                     <oa:hasTarget
> rdf:target="#ct-f6c5ea6e-6458-4799-874d-7f3d365d260d" />
>                     <oa:hasBody>
>                         <oa:SemanticTag
> rdf:about="http://purl.bioontology.org/ontology/SNOMEDCT/365761000" />
>                     </oa:hasBody>
>                 </oa:Annotation>
>             </rdf:RDF>
>         </xs:appinfo>
>     </xs:annotation>
>     <!-- ... -->
>   </xs:complexType>
> Here I use the xml:id on the complex type to make it easy to refer to
> it by #anchor and reduce the verbosity a bit. Of course RDF/XML does
> work against us a bit in its verbose form.
> But unless you want to do something more about the annotation, like
> referring to it (give it an rdf:about), adding provenance, or build
> some kind of relations between these complex types, then I would think
> it would be easier to just do (again syntax not checked):
>   <xs:complexType name="ct-f6c5ea6e-6458-4799-874d-7f3d365d260d">
>     <xs:annotation>
>         <xs:appinfo>
> <dcterms:source>http://purl.bioontology.org/ontology/SNOMEDCT/365761000</dcterms:source>
>         </xs:appinfo>
>     </xs:annotation>
>   </xs:complexType>
> This should comply with the schema at
> http://www.dublincore.org/schemas/xmls/qdc/dcterms.xsd which you can
> add if you want.
> I'm not sure about dcterms:source vs dcterms:identifier  (or
> motivation oa:tagging or also adding oa:identifying) - that depends on
> the nature of your complex types.
> Also xs:appinfo takes a source attribute.. so the simplest might just be:
> <xs:appinfo source="http://purl.bioontology.org/ontology/SNOMEDCT/365761000" />
> On Sat, Mar 2, 2013 at 2:23 PM, Timothy W. Cook
> <timothywayne.cook@gmail.com> wrote:
>> HI All,
>> Though I have read virtually everything I can find related to this
>> subject; including:
>> http://lists.w3.org/Archives/Public/public-openannotation/2013Feb/0051.html
>> I really don't see the answer to my question.
>> First of all this is a "green field" area.  I do not have to be
>> concerned with existing documents and how it has been done in the
>> past.
>> I just want to get this right, the first time. Given all the
>> experience from people here.
>> Scenario:
>> I have XML Schemas that define data instance structures (as usual).
>> These schemas use a lot of complexTypes that are restrictions from a
>> base schema.  Since each base schema complexType can be represented in
>> a schema multiple times with different restrictions, I use a UUID
>> based name. For example:
>>   <xs:complexType name="ct-f6c5ea6e-6458-4799-874d-7f3d365d260d">
>>         <xs:complexContent>
>>             <xs:restriction base="mlhim2:DvQuantityType">
>>                 <xs:sequence>
>> ...
>> These complexTypes are almost always definable via a controlled
>> vocabulary, ex. SNOMED-CT
>> In order to add semantics to the complexType definition my current
>> thought is to use:
>>   <xs:complexType name="ct-f6c5ea6e-6458-4799-874d-7f3d365d260d">
>>     <xs:annotation>
>>       <xs:appinfo>
>>         <rdfs:isDefinedBy
>> rdfs:resource="http://purl.bioontology.org/ontology/SNOMEDCT/365761000"/>
>>       </xs:appinfo>
>>     </xs:annotation>
>>         <xs:complexContent>
>>             <xs:restriction base="mlhim2:DvQuantityType">
>>                 <xs:sequence>
>> ...
>> Which will identify this complexType as a Sodium level finding
>> according to SNOMED-CT.
>> My first question is:
>> 1) is it correct to make the assumption that the annotation applies to
>> the enclosing complexType without using an rdf:about (or similar)
>> definition?
>> 2) is rdfs:isDefinedBy the "tag" to use, or is something like
>> oa:SemanticTag a better choice?
>> Realizing that these annotations will not be reproduced in the
>> instance data.  The eco-system around this says that to determine the
>> full semantics you must have the schema associated with any instance
>> data.
>> Thoughts?
>> Cheers,
>> Tim
>> --
>> ============================================
>> Timothy Cook, MSc           +55 21 94711995
>> MLHIM http://www.mlhim.org
>> Like Us on FB: https://www.facebook.com/mlhim2
>> Circle us on G+: http://goo.gl/44EV5
>> Google Scholar: http://goo.gl/MMZ1o
>> LinkedIn Profile:http://www.linkedin.com/in/timothywaynecook
> --
> Stian Soiland-Reyes, myGrid team
> School of Computer Science
> The University of Manchester

Timothy Cook, MSc           +55 21 94711995
MLHIM http://www.mlhim.org
Like Us on FB: https://www.facebook.com/mlhim2
Circle us on G+: http://goo.gl/44EV5
Google Scholar: http://goo.gl/MMZ1o
LinkedIn Profile:http://www.linkedin.com/in/timothywaynecook
Received on Tuesday, 5 March 2013 12:19:50 UTC

This archive was generated by hypermail 2.3.1 : Tuesday, 6 January 2015 20:22:03 UTC