Your Federal Quarterly Tax Payments are due April 15th Get Help Now >>

OBO Edit tutorial by MikeJenny


									      OBO-Edit tutorial

      David Osumi-Sutherland
FlyBase / Virtual Fly Brain / OBO-Edit
      Working Group (OEWG)
• Slides and test tutorial can be downloaded
  from the bottom of the Tutorial wiki page:

• The latest version of OE2 (beta release), is
                   Your backgrounds
• Who here has never used an ontology editing
• Who here is an OBO-Edit user?
    – If you are, have you used Cross-Products?
• Who here is a Protégé user?
        • Protégé 3
        • Protégé 4
             – With reasoner?

• For those of you who speak OWL(ish), I'll try to provide translations to
  OWL Manchester syntax.
          OBO 101
•   An ontology contains terms (e.g. hand) and
    relationships (e.g. hand has_part finger)

•   Terms refer to types (classes).

•   Types are classifications of things
    (instances) in the real world, based on
    some set of criteria.
     – My left hand is an instance of the type hand

•   The criteria for membership of a class
    (type) is recorded using textual definitions,
    relationships, or some combinations of the
     – name: hand
     – def: “An anatomical structure that has four
       fingers and a thumb and is attached to the
       end of an arm.” *reference: DOS+
     – relationship: hand has_part finger
     – relationship: hand has_part thumb
     – relationship: part_of arm                      Image from Gray’s Anatomy (copyright
 OBO basics- instance/type distinction
• If OBO terms refer to types, why worry about
  – instances are central to defining OBO type-level

• OBO <-> OWL:
  – OWL class = OBO type
  – OWL individual = OBO instance
                            OBO relations
• Instance level relations (by convention written in bold)
    – 'my left little finger' part_of 'my left hand'
        • Note – quantifiers – all, some – are not needed.
• Type level relations (by convention, written in italic).
    – Type level relations are defined using instance level relations + quantifiers.
        • In OBO, the quantifiers (all, some) are buried in the definition of the
          type-level relation.
             – e.g.- X part_of Y is defined as:
                  » for all x,t if Xxt then there is some xy such that Yyt and x
                     part_of y at t
• OBO <-> OWL:
    – OBO instance level relation = OWL property
    – In OWL, quantifiers are used explicitly in ontology construction when relating
        • OBO: finger part_of hand can be written in OWL using the OBO instance
           level relation with added quantifiers: all finger part_of some hand *
    – OBO is_a = OWL SubClassOf

*Ignoring the time component of the OBO definitions, as this cannot be expressed in OWL
• It is critical to be aware of the direction of quantifiers when using OBO

True: All breasts are part of some human
False: All humans have breasts

True: All vertebrate motor neurons release neurotransmitter acetylcholine
False: All neurons that release acetylcholine are vertebrate motor neurons.

Be especially careful in cases where the instance level relation is symmetric:

True: All lion’s mane connected_to some lion’s neck
False: All lion’s neck connected_to some lion’s mane
    Relationships and definitions
• You should think of the relationships a term
  has as a formalised part of their definition.
• A regular relationship in OBO (SubClassOf in
  OWL) specifies necessary conditions for
  membership of a class.
  – e.g. finger part_of hand (all finger part_of some
    hand) states that a necessary condition of being in
    the class finger is to be part of some hand.
• If a relation is transitive:
   – A rel B rel C rel D therefore A rel D
      • U1 neuron is_a U neuron is_a motor neuron
         – therefore U1 neuron is_a motor neuron
      • ellipsoid body part_of central complex part_of adult
         – therefore ellipsoid body part_of adult brain
     Transitivity and redundancy
• ellipsoid body part_of central complex part_of
  adult brain
  – therefore ellipsoid body part_of adult brain
     • therefore asserting the relationship "ellipsoid body
       part_of adult brain" in your ontology would be
        Some simple reasoning
• U neuron part_of larval antennal segment
  – (All U neuron part_of some larval antennal segment)
• U1 neuron is_a U neuron
• therefore U1 neuron part_of larval antennal
  – (All U neuron part_of some larval antennal segment;
    U1 neuron SubClassOf U neuron therefore…)
• So, adding 'U1 neuron' part_of 'larval antennal
  segment’ would be redundant.
Demo – OBO basics
     Basic OBO-Edit2 editing setup
•   - 2 x Ontology Tree Editor (OTE)
•   - One parent editor
•   - One text editor
•   - One search panel
•   - One reasoner manager
•   - One graph viewer (Note - currently only
    works with Link Pile Reasoner on)
                  Browsing - Trees
      The ontology tree editor is a good way to browse down the
      ontology graph, but not all parents visible in one view

 Click to
expand or

Preferences                     save a picture

              Quick Filtering
                   Browsing - parents
The parent editor provides a quick way to check all parental
relationships – usually these are not all these are visible in a single
tree view

Preferences          save a picture

Preferences          save a picture
       Graph viewer setup

For an uncluttered view:
                   Browsing - graphs
A good way to view and browse ancestral relationships, graphs of ancestors via
transitive relations answer questions
e.g.- what is X? What is X part of? What does X develop from?

 Note – currently requires link pile reasoner to be turned on.
Browsing – The Text Editor
Basic Searching - single leg
    Basic searching – multi-leg

Add new leg
               nesting (parentheses)   Remove leg
All searches can also be filters or
Rendering options
Drag and drop editing in the ontology
          tree editor (OTE)
• Left clicking a term choose it
• Right clicking displays a menu of editing
• Dragging and dropping single or multiple
  terms allows terms to be copied, moved or
Global vs local selection modes

                        local mode
                    -selection in other
                   components doesn’t
                   affect selection here

                      global mode
                      - 2 way auto
                    sync with other
Drag and drop term move
Drag and drop term move
Drag and drop term move
Drag and drop term
                 Making new terms
• First, make sure your ID generator is set up
                                Edit profile

                                           start from   end at
     ID prefix      ID length
Create new child

Check this box to commit text edits automatically.

             Note, committing will not change your ontology file
Deletion, obsoletion, destruction
OTE – right click menu:

… deletes the relationship between the selected term and its immediate
parent in the ontology tree editor. When the selected term has only one
parent, this option switches to:

 … changes the status of term to obsolete. The OBO file retains
 the ID for future reference and to prevent re-use. To indicate
 replacement terms, drag suitable terms to the obsoleted term

Within the context of a single editing session, or a pre-release file, you may
wish instead to destroy the term completely (BUT BE CAREFUL!)
                             Parent Editor
Delete parent relationship

                                 Does what it says. But be careful it adds is_a
                                 parents by default. For other relations, switch
                                 after adding
Graph Editor
                    Graph Editor

Hide parent terms                   show parent terms

Hide child terms                     show child terms
                        hide term

• Right click provides editing options and
• Choosing quick filtering => manageable
Making new relationships in the graph
        editor – demo only
                 Time savers
• Cloning
  – Right click clone option makes clone of chosen
    term – identical in every way except for ID and
    ‘CLONE OF’ appended to term name
• Create multiple children
  – Right click ‘create multiple children’ option. Does
    what is says on the box. Pops up interface were a
    bunch of new terms can be named at once.
Managing multiple inheritance
• X disjoint_from Y
  – Nothing that is an instance of X is also an instance of Y.
     • e.g. anatomical structure disjoint_from biological process
         – Nothing exists that is an instance of both of these types.
  – Extremely useful for error checking
  – also speeds up some reasoners

• OBO <-> OWL
  – 0BO disjoint_from ≅ OWL DisjointWith
     Using the reasoner to check for
        disjoint violations - demo
• In the test ontology, make one of the children of
  biological process an is_a child of sensillum.
• Now run the link pile reasoner
• Undo

• Making disjoints - demo
   – by hand
   – automatically making all children disjoint (use
              Ways to classify neurons
• sensory
    – Sensory modality
    – Sense organ
•   motor
•   interneuron
    – local
    – relay
• neurotransmitter
    – serotonergic,
    – dopaminergic…
• Location
    – cell body
    – fasciculation pattern (e.g.- labial nerve)
    – innervation pattern (antennal lobe glomerulus DL1)

all siblings in the same color are (probably) disjoint_from each other.
      Multiple inheritance needed
• Name: ORN ab1a
• Def: A cholinergic olfactory neuron whose
  dendrite innervates an ab1 basiconic sensillum on
  the 3rd segment of the antenna. Like other
  antennal olfactory neurons, it sends an axon
  through the antennal nerve that innervates a
  single antennal lobe glomerulus DL1
  –   olfactory neuron
  –   cholinergic neuron
  –   antennal sensory neuron
  –   DL1 innervating neuron
Multiple inheritance is very hard to manage by

                    It is difficult to keep track of multiple
                    classification chains to:
                    ensure completeness;
                    avoid redundancy;
                    avoid introducing error due to inheritance
                    of classification criteria from a distant ancestor
              Cross Products
• In OBO, cross products, also known as
  intersections, provide a way to record
  necessary and sufficient definitions.
• necessary and sufficient definitions allow
  classification to be automated using reasoners

• OBO <-> OWL
  – intersection_of ≅ EquivalentTO
            Genus and Differentia
• Anatomy of a cross product:
   – name: antennal sensillum
   – genus: sensillum
   – differentium: (part_of antenna)

• In OBO format
   – intersection_of: sensillum
   – intersection_of: part_of antenna

• In OWL:
   – EquivalentTO: sensillum and part_of some antenna
           OBO-Edit reasoners
• OBO-Edit2 currently has 3 reasoners

• In the near future, 2 of these will be retired,
  leaving just the ‘rule based reasoner’ (RBR)

• Currently the link pile reasoner is needed for
  flagging disjointness violations and for running
  the graph viewer. For everything else you
  should use the RBR
           Cross Product Demo
• Choose the term 'antennal sensillum'
  – Check out the text editor cross product tab
• Turn the reasoner off.
  – You should see antennal sensillum at the root
• Run the rule-based-reasoner
  – check out how the term is integrated non-
    redundantly into the classification hierarchy.
  – view the parent editor
          Cross Product Demo
• Using terms from other ontologies
  – cholinergic neuron
  – olfactory sensillum
 Making new cross product terms
• Add a new root class:
           Cross Product demo
• Making new cross products
  – glutamatergic neuron
  – taste sensillum
  – chemosensory sensillum
• Re-run the rule-based-reasoner
• Check the sensillum hierarchy
  – Explain how olfactory sensillum got its parent
 Useful renders for working with cross-
• Cross-Product detector:

• Multiple asserted inheritance detector:

• Unclassified term detector:

• Incompletely classified term detector:
     Combining Cross-Products with
    relationships => hidden assertions
• How can we record the generalization – All neurons with the
  function ‘smell’ are cholinergic?
   –   name: olfactory receptor neuron
   –   intersection_of: neuron
   –   intersection_of: has_function smell
   –   relationship: releases_neurotransmitter acetylcholine
   –   (OWL: EquivalentTo( neuron AND has_function some smell ), SubClassOf(
       releases_neurotransmitter some acetylcholine )
• Why is this potentially dangerous?
   –    Future editors using ‘has_function smell’ to record the function of a neuron class
       may not be aware that they are adding the assertion that the class is cholinergic
• Safeguards:
   – if neurons classifed by neurotransmitter are disjoint, the reasoner can flag
   – Keep a record of all examples (perhaps as a standardised comment)
   – State this assertion in the term definition with a link to a supporting reference.
Hidden assertion demo
          Detecting redundancy with the
     Use the Rule Base Reasoner*

    Redundant relationship

*Link pile reasoner over-flags redundancy when cross-product terms are present
If the reasoner is flagging relationships
     you don’t think are redundant

• Are you sure your intended meaning for a
  relationship is transitive?
  – e.g.- develops_from (transitive) is sometimes used
    as if it means ‘directly develops from’ (non-
  – In that case – request a new relation.

  – If you are interested in how to link relations such as develops_from and
    develops_directly_from so that they can be used for reasoning, please ask me
    or Chris after the tutorial
          Advanced Searching
• OE2 can combine string searching and logical
• Logical querying requires the reasoner to be
  turned on.
                           Logical queries
                              ** Note – reasoner required **
Find all sensilla that are part of some head:

The first leg of the search finds all subtypes of sensillum. The second leg finds all parts of
the head. The ‘matches all’ radio button ensures the two legs are combined by a
boolean AND.

OWL-DL: sensillum and part_of some head
                            Logical queries
                                ** Note – reasoner required **

 How is sensillum classified?

What does adPN DL1 develop_from ?

Note – this query has no OWL equivalent
  Importing foreign ‘helper’ terms
• Formalising definitions is likely to require
  terms from other ontologies.
• If you want to reason using the classification
  from another ontology, you need to import
  the full classification of each term.
• In order to keep up-to-date, you need a
  mechanism to re-import the foreign terms you
          Creating and maintaining a helper
                     term filter
1.     Open foreign ontology and run the rule based reasoner
2.     In the search tool, add the following two filter legs for each helper term

               First leg finds helper term

     2nd leg finds terms that classify               Load / Save
     helper term

Saving helper terms
                  Saving helper terms
                                                  Make sure “allow
                                                  dangling parents” is
 Check filter terms                               NOT checked

Avoid importing foreign ID rules   Record version of foreign ontology here
Saving helper terms

             Load helper term filter
       Refreshing helper terms
• The examples I’ve shown here use term
• This make the filter easy to read and edit, but
  names often change.
• Therefore more sustainable to use IDs instead.
 Instantiating inferred is_a for release
• If your users are not using your ontology with
  a reasoner, you made need to pre-reason for

• To do this, you can use the ‘save implied links’
  function in the save interface:
    Acknowledgements – OBO-Edit
• Current developers
  – Amina Abdulla
  – Chris Mungall
  – Jennifer Deegan

• Former developers
  – John Day-Richter
  – Nomi Harris
              Acknowledgements - OEWG
•   Amina Abdulla, Chris Mungall, Karen Eilbeck, Suzanna Lewis, - BBOP, LBNL, Berkeley, CA, USA
•   Midori A. Harris, Jennifer Deegan, Amelia Ireland, Jane Lomax - GO-EBI, Hinxton, UK
•   David Hill, Alexander D. Diehl, Harold Drabkin - MGI, The Jackson Laboratory, Bar Harbor, ME, USA
•   Karen R. Christie - SGD, Department of Genetics, Stanford University, Stanford, CA, USA
•   Tanya Berardini - TAIR, Carnegie Institution, Department of Plant Biology, Stanford, CA, USA
•   Petra Fey - DictyBase, Northwestern University, Chicago, IL, USA
•   Carol A. Bastiani, Ranjana Kishore - WormBase, California Institute of Technology, Pasadena, CA, USA
•   Victoria Petri - RGD, Medical College of Wisconsin, Milwaukee, WI, USA
•   Colin Batchelor- Royal Society of Chemistry, Cambridge UK
•   Shuly Avraham - Cold Spring Harbor Laboratory, Cold Spring Harbor, NY
•   Pankaj Jaiswal - Gramene, Department of Plant Breeding, Cornell University, Ithaca, NY, USA
•   Melissa Haendel - ZFIN, University of Oregon, Eugene, OR, USA
•   John Osborne - Robert H. Lurie Cancer Center, Northwestern University, Chicago, IL, USA
•   Michael Ashburner
•   FlyBase
•   Virtual Fly Brain
•   ICBO

To top