At least according to Jason Lim from the “World Scientific Team”. Clearly a reputable journal which I will be more than happy to advertise to everyone in my
pattern recognition knowledge engineering “something with computers” research group.
Reading material: “Interactive ontology revision”
This is the second in a series of blog posts on “interesting explanation/debugging papers I have found in the past few months and that I think are worth sharing”. I’m quite good with catchy titles!
Nikitina, N., Rudolph, S., Glimm, B.: Interactive ontology revision. J. Web Sem. 12: 118-130 (2012) [PDF]
This paper follows a semi-automated approach to ontology repair/revision, with a focus on factually incorrect statements rather than logical errors. In the ontology revision process, a domain experts inspects the set of ontology axioms, then decides whether the axiom is correct (should be accepted) or incorrect (axiom is rejected). Each decision thereby has consequences for other axioms, as they can be either automatically accepted (if they follow logically from the accepted axioms) or rejected (if they violate the accepted axioms). Rather than showing the axioms in random order, the proposed system determines the impact a decision has on the remainder of the axioms (using some ranking function), and gives higher priority to high impact items in order to minimize the number of decisions a user has to make in the revision process. This process is quite similar to Baris Sertkaya’s FCA-based ontology completion approach, which employs the same “accept/decline” strategy.
The authors also introduce “decision spaces”, a data structure which stores the results of reasoning over a set of axioms if an axiom is accepted or declined; using this auxiliary structure saves frequent invocation of a reasoner (83% of reasoner calls were avoided in the revision tool evaluation). Interestingly, this concept on its own would make for a good addition to OWL tools for users who have stated that they would like a kind of preview to “see what happens if they add, remove or modify an axiom” while avoiding expensive reasoning.
Conceptually, this approach is elegant, straightforward, and easily understandable for a user: See an axiom, make a yes/no decision, repeat, eventually obtain a “correct” ontology. In particular, I think it the key strengths are that 1) a human user makes decisions whether something is correct or not, 2) these decisions are as easy as possible (a simple yes/no), and 3) the tool (shown in the screenshot above) reduces workload (both in terms of “click count” as well as cognitive effort, see 2)) for the user. In order to debug unwanted entailments, e.g. unsatisfiable classes, the set of unwanted consequences can be initialised with those “errors”. The accept/decline decisions are then made in order to remove those axioms which lead to the unwanted entailments.
On the other hand, there are a few problems I see with using this method for debugging: First, the user has no control over which axioms to remove or modify in order to repair the unwanted entailments; in some way this is quite similar to automated repair strategies. Second, I don’t think there can be any way of the user actually understanding why an entailment holds as they don’t get to see the “full picture”, but only one axiom after another. And third, using the revision technique throughout the development process, starting with a small ontology, may be doable, but debugging large numbers of errors (for example after conversion from some other format into OWL or integrating some other ontology) seems quite tedious.
Reading material: “Direct computation of diagnoses for ontology debugging.”
After my excursion into the world of triple stores, I’m back with my core research topic, which is explanation for entailments of OWL ontologies for the purpose of ontology debugging and quality assurance. Justifications have been the most significant approach to OWL explanation in the past few years, and, as far as I can tell, the only approach that was actually implemented and used in OWL tools. The main focus of research surrounding justifications has been on improving the performance of computing all justifications for a given entailment, while the question of “what happens after the justifications have been computed” seems to have been neglected, bar Matthew Horridge’s extensive work on laconic and precise justifications, justification-oriented proofs, and later the experiments on the cognitive complexity of justifications. Having said that, in the past few months I have come across a handful of papers which cover some interesting new(ish) approaches to debugging and repair of OWL entailments. As a memory aid for myself and as a summary for the interested but time-pressed reader, I’m going to review some of these papers in the next few posts, starting with:
Shchekotykhin, K., Friedrich, G., Fleiss, P., Rodler, P.: Direct computation of diagnoses for ontology debugging. arXiv 1–16 (2012) [PDF]
The approach presented in this paper is directly related to justifications, but rather than computing the set of justifications for an entailments which is then repaired by repairing or modifying a minimal hitting set of those justifications, the diagnoses (i.e. minimal hitting sets) are computed directly. The authors argue that justification-based debugging is feasible for small numbers of conflicts in an ontology, whereas large numbers of conflicts and potentially diagnoses pose a computational challenge. The problem description is quite obvious: For a given set of justifications, there can be multiple minimal hitting sets, which means that the ontology developer has to make a decision which set to choose in order to obtain a good repair.
Minor digression: What is a “good” repair?
“Good repair” is an interesting topic anyway. Just to clarify the terminology, by repair for a set of entailments E we mean a subset R of an ontology O s.t. the entailments in E do not hold in O R; this set R has to be a hitting set of the set of all justifications for E. Most work on justifications generally assumes that a minimal repair, i.e. a minimal number of axioms, is a desirable repair; such a repair would involve high power axioms, i.e. axioms which occur in a large number of justifications for the given entailment or set of entailments. Some also consider the impact of a repair, i.e. the number of relevant entailments not in E that get lost when modifying or removing the axioms in the repair; a good repair then has to strike a balance between minimal size and minimal impact.
Having said that, we can certainly think of a situation where a set of justifications share a single axiom, i.e. they have a hitting set of size 1, while the actual “errors” are caused by other “incorrect” axioms within the justifications. Of course, removing this one axiom would be a minimal repair (and potentially also minimal impact), but the actual incorrect axioms would still be in the ontology – worse even, the correct ones would have been removed instead. The minimality of a repair matters as far as users are concerned, as they should only have to inspect as few axioms as possible, yet, as we have just seen, user effort might have to be increased in order to find a repair which preserves content, which seems to have higher priority (although I like to refer to the anecdotal evidence of users “ripping out” parts of an ontology in order to remove errors, and some expert systems literature which says that users prefer an “acceptable, but quick” solution over an ideal one!). Metrics such as cardinality and impact can only be guidelines, while the final decision as to what is correct and incorrect wrt the domain knowledge has to be made by a user. Thus, we can say that a “good” repair is a repair which preserves as much wanted information as possible while removing all unwanted information, but at the same time requiring as little user effort (i.e. axioms to inspect) as possible. One strategy for finding such a repair while taking into account other wanted and unwanted entailments would be diagnoses discrimination, which is described below.
Now, back to the paper.
In addition to the ontology axioms and the computed conflicts, the user also specifies a background knowledge (those axioms which are guaranteed to be correct), and sets of positive (P) and negative (N) test cases, such that the resulting ontology O entails all axioms in P and does not entail the axioms in N (an “error” in O is either incoherence/inconsistency, or entailment of an arbitrary axiom in N, i.e. the approach is not restricted to logical errors). Diagnoses discrimination (dd) makes use of the fact that different repairs can have different effects on an ontology, i.e. removing repair R1 and R2 would lead to O1 and O2, respectively, which may have different entailments. A dd strategy would be to ask a user whether the different entailments* of O1 and O2 are wanted or unwanted, which leads to the entailments being added to the set P or N. Based on whether the entailments of O1 or O2 are considered wanted, repair R1 or R2 can be applied.
With this in mind, the debugging framework uses an algorithm to directly compute minimal diagnoses rather than the justifications (conflict sets). The resulting debugging strategy leads to a set of diagnoses which do not differ wrt the entailments in the respective repaired ontologies, which are then presented to the user. When taking into account the set of wanted and unwanted entailments P and N, rather than just presenting a diagnosis without context, this approach seems fairly appealing for interactive ontology debugging, in particular given the improved performance compared to justification-based approaches. On the other hand, while justifications require more “effort” in comparison than being presented directly with a diagnosis, they also give a deeper insight into the structure of an ontology. In my work on the “justificatory structure” of ontologies, I have found that there exist relationships between justifications (e.g. overlaps of size >1, structural similarity) which add an additional layer of information to an ontology. We can say that they not only help repairing an ontology, but also potentially support the user’s understanding of it (which, in turn, might lead to more competence and confidence in the debugging process).
* I presume this is always based on some specification for a finite entailment set here, e.g. atomic subsumptions.
At this year’s International Semantic Web Conference ISWC 2011, Manchester will be heavily present with 4 papers in the research track, of which 2 focus on justifications.
In the first one, which we presented in similar form at DL, we discuss our user study on the cognitive complexity of OWL justifications. It is quite interesting that, despite the fairly large body of work on explanation for entailments, there have only been few attempts at analysing the effectiveness of explanation approaches with regard to how understandable they are to the average OWL user. Starting with fine-grain justifications (Kalyanpur, Parsia, Cuenca-Grau, DL 2006) which were then defined formally as laconic & precise justifications (Horridge, Parsia, Sattler, ISWC 2008 – won best paper award at the conference), there has been a line of research dealing with making justifications easier to understand by removing superfluous parts (i.e. parts of the axioms in the justification that are not necessary for the entailment to hold). The notion of (non-)laconicity is based on the assumption that superfluous parts distract the user and therefore make it harder to understand why the entailment holds – which, intuitively, seems sound. Moving away from distracting parts only, we want to have a general picture of how easy or difficult justifications are to understand, and why. These ideas are captured in a complexity model (again, Horridge, Parsia, Sattler) which considers certain properties of a justification and the respective entailment, and gives us a score for the cognitive complexity, or hardness of the justification. The considerations behind this model, issues related with cognitive issues, and the validation of the model are discussed in the paper “The Cognitive Complexity of OWL Justifications”, which we’re presenting at ISWC in October.
The second paper is part of my own PhD research and deals with “The justificatory structure of the NCBO BioPortal Ontologies”. Again, this is a topic which has hardly been touched yet by other researchers who deal with explanation in the form of minimal entailing subsets (i.e. MinAs, MUPS – if for unsatisfiable classes, justifications… maybe we should simply call them MEHs – minimal entailment-having subsets?). While we generally focus on a) finding efficient mechanisms for computing all MEHs, errmm, justifications, or b) analysing the cognitive complexity of individual justifications, there is only a small body of work that looks at multiple justifications. This seems an obvious step, since we know that considering individual justifications for an entailment in isolation does not give us the full picture of why an entailment holds in an ontology. The consequences can be only partial understanding, ineffectual repair attempts, or over-repair (removing or modifying more than necessary). Further, we even know that those multiple justification have relations between them, as they can share axioms, entail each other, be subsets of one another (if we consider justifications for multiple entailments), etc. To which degree multiple justifications occur in an ontology, and what relations there are between them, can tell us more about the ontology than the simple metrics we see in ontology editors – in the paper I call it ‘making implicit structure explicit’. An analysis of the prevalence of multiple justifications and their relations in a set of BioPortal ontologies is the focus of the paper, which, again, will be turned into a talk at ISWC.
And, in a amusing move, we have had the research track session which contains the two talks named after us: The ISWC organisers decided to call it “MANCHustifications”. You know where you can find us.
Off to DL…
We’ve been busy preparing talks and posters for the Description Logics workshop 2011 in Barcelona, which will start on Wednesday 13th July. I’m really looking forward to meeting researchers from the DL community and to hearing some interesting talks! The workshop program is packed with talks and presentations, so I’m sure there will be plenty to discuss.
The Manchester group will be present with two posters (Samantha Bail, Bijan Parsia and Ulrike Sattler. ‘Extracting Finite Sets of Entailments from OWL Ontologies’ and Chiara Del Vescovo. The Modular Structure of an Ontology: Atomic Decomposition with Labels’) and two talks (Matthew Horridge, Samantha Bail, Bijan Parsia and Ulrike Sattler. ‘The Cognitive Complexity of OWL Justifications’ and Rafael S. Gonçalves, Bijan Parsia and Uli Sattler. ‘Analysing Multiple Versions of an Ontology: A Study of the NCI Thesaurus’).
I’m planning to write a short review of the workshop on this blog during / after my stay in Barcelona – the weather forecast looks pretty bad, so I presume I’ll have time in my hotel room to write quite a bit.
You must be logged in to post a comment.