Introduction to OWL Web Ontology Language for Medical and Biosciences Applications

Existing Medical and Biosciences Ontology Projects

There are a number of ontology projects that exist at present. Here are some of them.

Resource Description Framework

As mentioned above, OWL is based on RDF, a language for describing resources.  One goal of RDF to help applications discover information on the web.  An example of an RDF language, other than OWL, is RDF Site Summary (RSS) 1.0, popularly used in news feeds.  RDF is described informally in the RDF Primer¹ and formally in the RDF/XML Syntax Specification².

RDF enables establishment and discovery of statements about resources. As an example, the statement

http://www.medicalcomputing.net/index.html has a creation-date whose value is April 12, 2006

can be represented in RDF has three parts

• the subject is the document with uniform resource locator (URL) 'http://www.medicalcomputing.net/index.html'
• the predicate is the word 'creation-date'
• the object is the phrase 'April 12, 2006'

This can be displayed graphically as

A simple RDF Relation

According to RDF conventions, the subject, 'http://www.medicalcomputing.net/index.html', is represented as an ellipse because it is a uniform resource identifier (URI) reference. URI's are a generalization of the familiar URL used for addresses of web pages.  They are described by Request for Comments (RFC) 2396: Uniform Resource Identifiers⁷. The object,  'April 12, 2006', is represented as a rectangle because it is a literal value (i.e. constant), and the relation 'creation-date' is represented as a line between them.  The statement can also be written as the triple

<http://www.medicalcomputing.net/index.html> <http://www.medicalcomputing.net/terms/creation-date> "April 12, 2006"

This can be written in XML as

<?xml version="1.0"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
         xmlns:medcomterms="http://www.medicalcomputing.net/terms/">
  <rdf:Description rdf:about="http://www.medicalcomputing.net/index.html">
     <medcomterms:creation-date>April 12, 2006</medcomterms:creation-date>
  </rdf:Description>
</rdf:RDF>

There is no need for the subject to be an Internet resource, such as a web page example above. It may be a person as well. In this case a URI is used.  For example, we could model the statement

Fred Flinstone as examined on April 12, 2006

as

<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" 
         xmlns:medcomterms="http://www.medicalcomputing.net/terms/">
  <rdf:Description rdf:about="http://www.w3.org/People/EM/contact#fred_flinstone">
     <medcomterms:was-examined>April 12, 2006</medcomterms:was-examined>
  </rdf:Description>
</rdf:RDF>

<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
             xmlns:contact="http://www.w3.org/2000/10/swap/pim/contact#">
  <contact:Person rdf:about="http://www.w3.org/People/EM/contact#fred_flinstone">
    <contact:fullName>Fred Flinstone</contact:fullName>
    <contact:mailbox rdf:resource="fflinstone@medicalcomputing.net"/>
  </contact:Person>
</rdf:RDF>

The person, Fred Flinstone is described as a by the URI http://www.w3.org/People/EM/contact#fred_flinstone.  Fred's full name and mailbox are also listed as properties.  Properties are a fundamental idea in RDF.  Properties are binary relationships between the individuals, or objects, or describe data values associated with objects.  Instances of properties can be written as ordered pairs.  For example, this instance of the property mailbox can be written (http://www.w3.org/People/EM/contact#fred_flinstone, "fflinstone@medicalcomputing.net").

The domain of a property restricts the individuals to which the property can be applied.  For example, we could define the domain of was-examined property to be people.  The range of a property restricts the values it can take.  For example, the range of the was-examined property may be defined as a valid date before the current point in time.

The concept of a class is described in the RDF Schema as a group of objects that share properties. For example, person could be defined as a class because individuals belonging to that class all have names and some have email addresses. The use of the term individual here is not casual.  RDF uses the term individuals to describe instances of classes. For example, Fred Flinstone is an instance of the class person, so he is an individual.  Despite the example use, the term individual in RDF and OWL does not just refer to people.  Classes may be organized in a hierarchy using the subClassOf relation.  For example, employee could be defined as a subclass of person.    

Tools

There a number of tools available for working with OWL and many of them are freely available.  This section lists some of them and the references section at the end of this article lists more.

Searching ontologies is something that most projects are going to need to do.  XML in general can be searched with XPath, a standard from the W3C³¹.  XPath is implemented by most eXensible Style Sheet Language Transformation (XSLT) processors.  Xalan is the XSLT processor used in the XSLT example in the related article Introduction to Extensible Markup Language for Chemistry and Biosciences.

XPath is a query language that can retrieve a selection of nodes from the input documents, or an atomic value, or more generally, any sequence allowed by the data model.  This can be enough for many applications but the more specific language SPARQL, which is a query language for RDF³².  McCarthy^33,34 discusses the use of SPARQL.  ARQ³⁵ is a SPARQL Processor for Jena. An online demo is provided at the sparql.org site³⁶.

<rdf:RDF
    xmlns="http://www.medicalcomputing.net/owl/physiology.owl#"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
    xmlns:biochemistry="http://www.medicalcomputing.net/biochemistry.owl#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:daml="http://www.daml.org/2001/03/daml+oil#"
    xmlns:dc="http://purl.org/dc/elements/1.1/"
    xml:base="http://www.medicalcomputing.net/owl/physiology.owl">
  <owl:Ontology rdf:about="">
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string">A model for human physiology</rdfs:comment>
    <owl:imports rdf:resource="http://www.medicalcomputing.net/biochemistry.owl#"/>
  </owl:Ontology>

  <owl:Class rdf:about="#PhysiologicalSystem">
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string">
      A physiological system is a system within the body that functions as a unit.  The human physiological 
      system includes the circulatory, endocrine, gastrointestinal, immune, cardio-vascular, integumentary, 
      lymphatic, muscoloskeletal, reproductive, respiratory, and urinary systems.
    </rdfs:comment>
  </owl:Class>

The various kinds of physiological system (circulatory, endocrine, gastrointestinal, etc) will be defined as subclasses of the class PhysiologicalSystem.  This is appropriate because the circulatory system is a physiological system, an endocrine system is a physiological system, and so on.  Subclassing defines an is a relation, also known as an inheritance, a parent-child, or a type specialization relation.  The article Ontology Development 101: A Guide to Creating Your First Ontology⁸ discusses when to use subclassing versus properties (has a relation) when authoring ontologies in more detail.

I have included a lengthy description of the class PhysiologicalSystem, even though this is just an example, for a reason: to emphasize that this is where a subject matter expert (a physician in this case) should pour out their knowledge.  That knowledge is what users of the ontology are looking for and hoping to benefit by.  Again, the information created by subject matter experts and making this readily available to users is what matters.  The XML, the software, and all that goes with it exist to support human users. 

The class NervousSystem is defined to be a subclass of PhysiologicalSystem

  <owl:Class rdf:ID="NervousSystem">
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string">
      The nervous system senses the outside environment, the state of the body itself, 
      and initiates movement of the musculoskeletal system.</rdfs:comment>
    <rdfs:subClassOf>
      <owl:Class rdf:ID="PhysiologicalSystem"/>
    </rdfs:subClassOf>
  </owl:Class>

This can also be shown with a Unified Modeling Language (UML) class diagram, which also shows the other PhysiologicalSystem subclasses.

UML Class Diagram for PhysiologicalSystem and Subclasses

The open arrow in the diagram represents inheritance.

Next I will introduce a model to represent measurements and observations that a physician may use in determining the health of the physiological systems described above.  I will create a base class called Measurement and from that derive classes for pulse, blood pressure, body temperature, and the blood concentration of relevant chemical substances, such as glucose, calcium, sodium, and so on.  The list is incomplete but it illustrates the approach.

UML Class Diagram to Model Physiological Measurements

The reader might think at this point that the ontology for physiology will become very large and we should create separate ontologies for each specialization.  That is a good argument.  Then should not the BloodConcentrations belong to a pathology ontology?  Also, shouldn't the CirculatorySystem belong to a cardiovascular ontology? The reasons that I did not do this are

1. To do something basic, for example, describe a blood pressure measurement, will require importing specialty ontologies.
2. The specialty ontology should depend on the base ontology physiology, not the other way around.  Certainly, there should not be a two-way dependency.
   

To describe the substances measured in the blood I have created an example biochemistry ontology.  The relationship between the physiology ontology and the biochemistry ontology is shown below.

Ontology Relationships

This new ontology illustrates two points

1. It is a good practice to partition ontologies to keep them relevant and manageable.  Chemical defintions do not belong in a physiology ontology.
2. Separating classes into multiple ontologies promotes reuse.  A biochemistry ontology can potentially be used in many other biology related ontologies.
3. Minimization of dependencies is important.  It is reasonable for physiology to depend on biochemistry but not the other way around.
   

The blood concentration measures a particular chemical substance.  This can be described as a property of the BloodConcentration element:

  <owl:ObjectProperty rdf:ID="substanceMeasured">
    <rdfs:comment xml:lang="en">The substance measured in the laboratory test.</rdfs:comment>
    <rdfs:label xml:lang="en">Substance Measured</rdfs:label>
    <rdfs:range rdf:resource=http://www.medicalcomputing.net/owl/biochemistry.owl#Chemical"/>
    <rdfs:domain rdf:resource=BloodConcentration"/>
 </owl:ObjectProperty>

A property is a map from the domain to a range. Here the domain is the set of BloodConcentration entities and the range is the set of Chemical entities, which are shown in the class diagram below.

Class Diagram for Chemicals

To define a benchmark for interpreting results create a reference element for measurements in general and for blood concentration, in particular, define a healthy range.  This is shown in the class diagram below.

Class Diagram for Healthy Range

In this diagram the dashed line represents a dependency or a has a relation.  A measurement has a reference; a blood concentration has a healthy range.

  <DiastolicBloodPressureNormalRange rdf:ID="DiastolicBloodPressureNormalRange_AHA">
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string">
      The range recommended as normal by the American Heart Association (max 80 mmHg)
    </rdfs:comment>
    ...
    <upperValue rdf:datatype="http://www.w3.org/2001/XMLSchema#float">80.0</upperValue>
  </DiastolicBloodPressureNormalRange>

Collaboration between Users with OWL Now that we have seen the basics of OWL and looked at an example, I would like to ask the question who is going to use OWL?  The different users I imagine for a medical information system are shown in the figure below. Users of an OWL Medical Information System I mentioned a number of tools in a previous section.  Most of these tools are for data modeling and software development.  Subject matter experts are needed to create the content. In the medical information system this content is the information necessary to interpret the laboratory results and flag any problem results. One problem with the state of the art in ontology at present is that a subject matter expert needs to also be competent in data modeling.

A variation on subject matter expert is the person creating individual instances of classes.  This person need not be an expert in data modeling but needs to be able to select the appropriate class to instantiate.  In the medical information system this would be the person entering the laboratory test information.

The other users of this medical application are physicians and patients.  Those users explore and otherwise make use of the content created by the subject matter expert to interpret (physician) and view (patient) the laboratory test results in the context provided by the subject matter expert.

package net.medicalcomputing.owl.example;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.*;

import edu.stanford.smi.protegex.owl.ProtegeOWL;
import edu.stanford.smi.protegex.owl.model.OWLModel;
import edu.stanford.smi.protegex.owl.model.OWLNamedClass;

public class BioPaxLevel2 {
      

public static void main(String[] args) {

    String uri = "http://www.biopax.org/release/biopax-level2.owl";
    StringBuffer html = new StringBuffer(HEADER);
    StringBuffer detail = new StringBuffer();
		
    try {
	OWLModel owlModel = ProtegeOWL.createJenaOWLModelFromURI(uri);
	html.append(getClassList(owlModel));

private static StringBuffer getClassList(OWLModel owlModel) {
    StringBuffer sb = new StringBuffer(
	    "        <p>Go to BioPax Class:&nbsp;&nbsp;" +
	    "            <select id='jump_select' onchange='jump(this)';>\n");
    Collection classes = owlModel.getUserDefinedOWLNamedClasses();
    for (Iterator it = classes.iterator(); it.hasNext();) {
        OWLNamedClass cls = (OWLNamedClass) it.next();
        sb.append("                <option value='" + cls.getName() + "'>" + cls.getName() + "</option>\n");
    }
    sb.append(
            "            </select></p>\n" +
	    "        </form>\n");
    return sb;
}

    Collection classes = owlModel.getUserDefinedOWLNamedClasses();
    int i = 0;
    for (Iterator it = classes.iterator(); it.hasNext();) {
        OWLNamedClass cls = (OWLNamedClass) it.next();
        detail.append(
                "		<a name='" + cls.getName() + "'/>" +
                "		<h2>Class " + cls.getName() + "</h2>\n" +
                "		<p>Parent: ");

The next few lines find the parent class, which can hyperlink to it's own definition.

        Collection superclasses = cls.getNamedSuperclasses();
        for (Iterator superclassIt = superclasses.iterator(); superclassIt.hasNext(); ) {
            String parent = ((OWLNamedClass)superclassIt.next()).getName();
            detail.append("<a href='#" + parent + "'>" + parent + "</a> ");
        }
        detail.append("</p>\n");

Finally, the program appends the comments to the HTML file.

        detail.append(
                "		<p id='" + cls.getName() + "' tabindex='" + i + "'/>\n");
        Collection comments = cls.getComments();
        for (Iterator commentIt = comments.iterator(); commentIt.hasNext(); ) {
            detail.append(commentIt.next());
        }
        detail.append("</p<\n");
        i++;
    }
    html.append(detail);

The markup tags for the end of the HTML file are added and the buffer is written out to the file bio_pax_level2.html using the method writeToFile(). To run the program enter the follow command at a command prompt.

>java -cp classes;lib/AbstractSyntax.jar;lib/commons-lang-2.0.jar;lib/commons-logging.jar;lib/icu4j.jar;lib/jena.jar;lib/OWLDoc.jar;lib/protege.jar;\
        lib/protege-owl.jar;lib/standard-extensions.jar net.medicalcomputing.owl.example.BioPaxLevel2

Summary

About Author

Alex Amies is a software engineer.  He has a BS in Computer Science from the University of New South Wales and an MS in Engineering from Stanford University.  He can be contacted at alexamies@gmail.com.

Related Reading

1. Alex Amies, 2006.  Introduction to Data Modeling for Physiology: The Human Endocrine System.
2. Alex Amies, 2006.  Introduction to Extensible Markup Language for Chemistry and Biosciences.
   

References

1. World Wide Web Consortium (W3C) 2004.  RDF Primer, W3C Recommendation 10 February 2004 at www.w3.org/TR/rdf-primer/.
2. W3C 2004.  RDF/XML Syntax Specification (Revised), W3C Recommendation 10 February 2004 at www.w3.org/TR/rdf-syntax-grammar/.
   
3. W3C 2004. OWL Web Ontology Language Reference.  W3C Recommendation 10 February 2004 at www.w3.org/TR/owl-ref/.
4. W3C 2004.  OWL Web Ontology Language Overview, W3C Recommendation 10 February 2004 at www.w3.org/TR/2004/REC-owl-features-20040210/.
5. W3C 2004.  OWL Web Ontology Language Guide, W3C Recommendation 10 February 2004 at www.w3.org/TR/2004/REC-owl-guide-20040210/.
6. OWL Web Ontology Language Semantics and Abstract Syntax, W3C Recommendation 10 February 2004 at www.w3.org/TR/owl-semantics/.
7. Internet Engineering Task Force (IETF), 1998.  Request for Comments 2396: Uniform Resource Identifiers (URI): Generic Syntax at www.ietf.org/rfc/rfc2396.txt.
8. Natalya F. Noy  and Deborah L. McGuinness, 2001. Ontology Development 101: A Guide to Creating Your First Ontology at www.ksl.stanford.edu/people/dlm/papers/ontology101/ontology101-noy-mcguinness.html.
9. Dublin Core Metadata at home page, http://dublincore.org/.
10. The Karlsruhe Ontology and Semantic Web Tool Suite at kaon.semanticweb.org.
11. Ontoknowledge Home Page at www.ontoknowledge.org/.
12. University of Maryland Simple HTML Ontology Extensions (SHOE) home page at www.cs.umd.edu/projects/plus/SHOE/.
    
13. KR Home Page at kr.org/.
14. James Hendler, Tim Berners-Lee, and Eric Miller 2002.  Integrating Applications on the Semantic Web,  Journal of the Institute of Electrical Engineers of Japan, Vol 122(10), October, 2002, p. 676-680 at www.w3.org/2002/07/swint.
15. Stanford University, Protégé ontology editor and knowledge-base framework at protege.stanford.edu/.  The Protégé API Javadoc is at protege.stanford.edu/doc/pdk/api/index.html, the Protégé-OWL Programmers Guide is at protege.stanford.edu/plugins/owl/api/guide.html, and the Protégé-OWL API Javadoc is at protege-owl.sourceforge.net/javadoc/.
16. BioPAX open source project at www.biopax.org/, BioPAX – Biological Pathways Exchange Language, Level 2, Version 1.0 Documentation at www.biopax.org/release/biopax-level2-documentation.pdf.
17. University Of Manchester 2004.  OWLDoc home page at www.co-ode.org/downloads/owldoc/co-ode-index.php.
18. US National Library of Medicine, Unified Medical Language System at www.nlm.nih.gov/research/umls/umlsmain.html.  The Knowledge Source Server Logon is at umlsks.nlm.nih.gov/kss/servlet/Turbine/template/admin,user,KSS_login.vm.
19. Stanford KSL Network Services, ontology software tools at http://www-ksl-svc.stanford.edu:5915/.
20. Stanford University, Chimæra ontology research project at www.ksl.stanford.edu/software/chimaera/.
    
21. The Open Biomedical Ontologies at http://obo.sourceforge.net/.
    
22. Gene Ontology page at www.geneontology.org/.
23. W3C 2006. SPARQL Query Language for RDF: W3C Candidate Recommendation 6 April 2006 at www.w3.org/TR/rdf-sparql-query/.
24. The National Center for Biomedical Ontology web site at bioontology.org/.
25. The European Bioinformatics Institute has a Ontology Lookup Service at www.ebi.ac.uk/ontology-lookup/ and software tools.
26. Generic Model Organism Database Construction Set open source project at gmod.sourceforge.net/ has a number of Java tools for bioinformatics ontology projects.
27. Standards and Ontologies for Functional Genomics at http://www.sofg.org/.
28. MGED Open Source Projects at http://mged.sourceforge.net/.
29. Plant Ontology™ Consortium at http://www.plantontology.org/.
30. The Trial Bank Project at rctbank.ucsf.edu/.
31. W3C Extensible Stylesheet Language Family (XSL) web page at www.w3.org/Style/XSL/.  The XML Path Language (XPath) 2.0: W3C Candidate Recommendation 3 November 2005 is at www.w3.org/TR/xpath20/.
32. W3C 2006.  SPARQL Query Language for RDF W3C Candidate Recommendation 6 April 2006 at www.w3.org/TR/rdf-sparql-query/.
33. Philip McCarthy 2005.  Search RDF data with SPARQL at www-128.ibm.com/developerworks/library/j-sparql/.
34. Philip McCarthy 2004.  Introduction to Jena at www-128.ibm.com/developerworks/java/library/j-jena/.
35. ARQ (A SPARQL Processor for Jena) is an open source project at http://jena.sourceforge.net/ARQ/.
36. SPARQLer - An RDF Query Demo at http://www.sparql.org/query.html.
37. Matthias Samwald, Case Western Reserve University, Psychoactive Drug Screening Program K_i database at kidb.cwru.edu/.