Efficient ontology debugging is a cornerstone for many activities in the context of the Semantic Web, especially when automatic tools produce (parts of) ontologies such as in the field of ontology matching. The best currently known interactive debugging systems rely upon meta information in terms of fault probabilities, which can speed up the debugging procedure in the good case, but can also have negative impact in the bad case. Unfortunately, assessment of meta information is only possible a-posteriori. Hence, as long as the actual fault is unknown, there is always some risk of suboptimal interactive diagnoses discrimination. As an alternative, one might prefer to rely on a no-risk strategy. In this case, however, possibly well-chosen meta information cannot be exploited, resulting again in inefficient debugging actions. In this work we present a reinforcement learning strategy that continuously adapts its behavior depending on the performance achieved and minimizes the risk of using low-quality meta information. Therefore, this method is suitable for application scenarios where reliable a-priori fault estimates are difficult to obtain. Using faulty ontologies produced by ontology matchers, we show that the proposed strategy outperforms both active learning and no-risk approaches on average w.r.t. required amount of user interaction.
The foundation for widespread adoption of Semantic Web technologies is a broad
community of ontology developers which is not restricted to experienced knowledge
engineers. Instead, domain experts from diverse fields should be able to create ontologies
incorporating their knowledge as autonomously as possible. The resulting ontologies
are required to fulfill some minimal quality criteria, usually consistency, coherency
and no undesired entailments, in order to grant successful deployment. However, the
correct formulation of logical descriptions in ontologies is an error-prone task which
accounts for a need for assistance in ontology development in terms of ontology
debugging tools. Things get even worse when independent standalone ontologies describing
related domains are unified to a single ontology (called aligned ontology) by adding a
set of suitable correspondences (called alignment) between signature elements of the
different ontologies. This task is addressed in the field of ontology matching where
researchers aim to produce automated tools for the generation of correspondences.
Applying such tools, however, often results in inconsistent/incoherent aligned ontologies
even though input ontologies (considered separately) do not violate any quality
criteria. Moreover, these aligned ontologies may exhibit a very complex fault structure as a
consequence of (1) adding many links between the single ontologies at once and since
? This research is funded by Austrian Science Fund (Project V-Know, contract 19996).
(2) the actual fault may be located in the produced alignment and/or in one or more
of the single ontologies, e.g. if a correct correpondence between two concepts
“activates” a fault in one of the single ontologies. In this vein, many different sources of
inconsistency/incoherence could arise (due to (1)) each of which may comprise parts of
each single ontology as well as of the alignment (due to (2)). In this work we present
an interactive approach dealing with the general problem of locating a fault throughout
the entire aligned ontology, not just in the alignment, as addressed by state-of-the-art
systems in ontology matching such as CODI [
Usually, ontology debugging tools [
In a debugging scenario involving a faulty ontology developed by one user, the meta information might be extracted from the logs of previous sessions, if available, or specified by the user based on their experience w.r.t. own faults. However, in scenarios involving automatized systems producing (parts of) ontologies as in ontology matching, the choice of reasonable meta information is rather unclear. If, on the one hand, an active learning method is used relying on a guess of the meta information, this might result in an overhead w.r.t. user interaction of more than 2000%. If one wants to play it safe, on the other hand, by deciding not to exploit any meta information at all, this might also result in substantial extra time and effort for the user. So, in the light of current stateof-the-art one is spoilt for choice between debugging strategies with high potential but also high risk, or methods with no risk but also no potential.
In this work we present an ontology debugging approach with high potential and low risk, which allows to minimize user interaction throughout a debugging session on average, without depending on high-quality meta information. By virtue of its reinforcement learning capability, our approach is optimally suited for debugging aligned ontologies, where only vague or no meta information is available. On the one hand, our method takes advantage of the given meta information as long as good performance is achieved. On the other hand, it gradually gets more independent of meta information if suboptimal behavior is measured. The method constantly improves the quality of meta information and adapts a risk parameter based on the new information obtained by querying the user. This means that, in case of good meta information, the performance of our method will be close to the performance of the active learning method, whereas, in case of bad meta information, the achieved performance will approach the performance of the risk-free strategy. So, our approach can be seen as a risk optimization strategy (RIO) which combines the benefits of active learning and risk-free strategies. Experiments on two datasets of faulty ontologies produced by ontology matching systems show the feasibility, efficiency and scalability of RIO. The evaluation of these experiments will manifest that, on average, RIO is the best choice of strategy for both good and bad meta information with savings in terms of user interaction of up to 80%.
The problem specification, basic concepts and a motivating example are provided in Section 2. Section 3 explains the suggested approach and gives implementation details. Evaluation results are described in Section 4. Section 5 concludes.
Ontology debugging deals with the following problem: Given is an ontology O which does not meet postulated requirements R.1 O is a set of axioms formulated in some monotonic knowledge representation language, e.g. OWL. The task is to find one of generally many alternative subsets of axioms in O, called target diagnosis Dt 2 O, that needs to be altered or eliminated from the ontology such that the resulting ontology meets the given requirements and has the intended semantics. The general debugging setting we consider also envisions the opportunity for the user to specify some background knowledge B, i.e. a set of axioms which are known to be correct. Moreover, we allow definition of a set P of positive (entailed) and a set N of negative (non-entailed) test cases, where each test case is a set of axioms.
More formally, ontology debugging can be defined in terms of conditions a target ontology must fulfill, which leads to the definition of a diagnosis problem instance, for which we search for solutions, i.e. diagnoses: Definition 1 (Target Ontology, Diagnosis Problem Instance). Let O = (T ; A) denote an ontology consisting of a set of terminological axioms T and a set of assertional axioms A, P a set of positive test cases, N a set of negative test cases, B a set of background knowledge axioms, and R a set of requirements to an ontology. Then an ontology Ot is called target ontology iff all the following conditions are fulfilled: 8 r 2 R : Ot [ B fulfills r 8 p 2 P : Ot [ B j= p 8 n 2 N : Ot [ B 6j= n The tuple hO; B; P ; N iR is called a diagnosis problem instance iff B [ (Sp2P p) 6j= n for all n 2 N and O is not a target ontology, i.e. O violates at least one of the conditions above.
Definition 2 (Diagnosis). We call D O a diagnosis w.r.t. a diagnosis problem
instance hO; B; P ; N iR iff there exists a set of axioms EXD such that (O n D) [ EXD
is a target ontology. A diagnosis D is minimal iff there is no D0 D such that D0 is
a diagnosis. A diagnosis D gives complete information about the correctness of each
axiom axk 2 O, i.e. all axi 2 D are assumed to be faulty and all axj 2 O n D are
assumed to be correct. The set of all minimal diagnoses is denoted by D.
The identification of an extension EXD, accomplished e.g. by some learning approach,
is a crucial part of the ontology repair process. However, the formulation of a complete
extension is outside the scope of this work where we focus on computing diagnoses.
Following the approach suggested in [
whenever not stated explicitly we assume R = fconsistency, coherencyg. and an assertional axiom A = fP hDStudent(s)g. Then O is inconsistent since it describes a PhD student as both a department member and not.
Let us assume that the assertion P hDStudent(s) is considered as correct and is
thus added to the background theory, i.e. B = A, and both sets P and N are empty.
Then, the set of minimal diagnoses D = fD1 : [ax 1]; D2 : [ax 2]; D3 : [ax 3]; D4 :
[ax 4]; D5 : [ax 5]; D6 : [ax 6]g for the given problem instance hT ; A; ;; ;i. D can be
computed by a diagnosis algorithm such as the one presented in [
With six diagnoses for six ontology axioms, this example might already give an idea
that in many cases the number of diagnoses D can get very large. Without any prior
knowledge, each of the diagnoses in D is equally likely to be the target diagnosis Dt,
that is selected by a user in order to formulate the intended ontology Ot := (O n Dt) [
EXDt . Identification of Dt can be accomplished by means of queries [
Definition 4 (Diagnosis Discrimination). Given the set of diagnoses D = fD1; : : : ; Dng w.r.t. hO; B; P ; N iR and a user u, find a sequence (X1; : : : ; Xq) of queries Xi 2 X with minimal q, such that D = fDtg after assigning Xi(i=1:::;q) each to either P iff au(Xi) = yes or N iff au(Xi) = no.3 A set of queries for a given set of diagnoses D can be generated as shown in Algorithm 1. In each iteration, for a set of diagnoses DP D, the generator gets a set of logical descriptions X that are entailed by each ontology Oi where Di 2 DP (function GETENTAILMENTS). When we speak of entailments, we always address the output computed by the classification and realization services of a reasoner [1, p.323 ff.]. These axioms X are then used to classify the remaining diagnoses in DnDP in order to obtain the partition hDP ; DN ; D;i associated with X. Then, together with its partition, X is added to the set of queries X. Note that in real-world applications, investigation of all possible subsets of the set D might be infeasible. Thus, it is common to approximate 2 For the sake of simplicity, we will use X instead of XD throughout this work because the D associated with X will be clear from the context. 3 Since the user u is assumed fixed throughout a debugging session and for brevity, we will use ai equivalent to au(Xi) in the rest of this work.
Algorithm 1: Query Generation
Input: diagnosis problem instance hO; B; P; N i, set of diagnoses D
Output: a set of queries and associated partitions X 1 foreach DP D do 2 X getEntailments(O; B; P; DP ); 3 if X 6= ; then 4 foreach Dr 2 D n DP do 5 if Or j= X then DP 6 else if Or [ X is inconsisteDntPth[enfDDNrg; 7 else D; D; [ fDrg; DN [ fDrg; 8 9 return X;
X
X [ DX; DP ; DN ; D;E the set of all minimal diagnoses by a set of leading diagnoses. This set comprises a predefined number n of minimal diagnoses.
The query generation algorithm returns a set of queries X that generally contains a
lot of elements. Therefore the authors in [
Entropy-based strategy, uses information about prior probabilities for a user to make
a fault in an axiom [
A diagnosis discrimination procedure can use either of the strategies to identify
the target diagnosis Dt. The result of the evaluation in [
Example (continued): In our example, if the user specifies p(ax i (i=1;:::;4)) = 0:001, p(ax 5) = 0:1 and p(ax 6) = 0:15. Given Dt := D2, the no-risk strategy scsplit (three queries) is more suitable than scent (four queries) because the fault probabilities disfavor D2. If Dt := D6, then the entropy-based strategy requires only two queries while it takes split-in-half three queries due to favorable fault probabilities.
We learn from this example that the best choice of discrimination strategy depends on the quality of the meta information in terms of prior fault probabilities. In cases where adequate meta information is not available and hard to estimate, e.g. Ontology Matching, the inappropriate choice of strategy might cause tremendous extra effort for the user interacting with the debugging system.
The proposed Risk Optimization Algorithm (RIO) extends entropy-based query selection strategy with a dynamic learning procedure that learns by reinforcement how to select optimal queries. Moreover, it continually improves the prior fault probabilities based on new knowledge obtained through queries to a user. The behavior of our algorithm can be co-determined by the user. The algorithm takes into account the user’s doubt about the priors in terms of the initial cautiousness c as well as the cautiousness interval [c; c] where c; c; c 2 [cmin; cmax] := [0; bjDj=2c =jDj], c c c and D contains at most n leading diagnoses (see Section 2). The interval [c; c] constitutes the set of all admissible cautiousness values the algorithm may take during the debugging session. High trust in the prior fault probabilities is reflected by specifying a low minimum required cautiousness c and/or a low maximum admissible cautiousness c. If the user is unsure about the rationality of the priors this can be expressed by setting c and/or c to a higher value. Intuitively, c cmin and cmax c represent the minimal desired difference in performance to a high-risk (entropy) and no-risk (split-in-half) query selection, respectively.
The relationship between cautiousness c and queries is formalized by the following definitions: Definition 5 (Cautiousness of a Query). We define the cautiousness caut (Xi) of a query Xi as follows: caut (Xi) := min jDiP j; jDiN j jDj
2 A query Xi is called braver than query Xj iff caut (Xi) < caut (Xj ). Otherwise Xi is called more cautious than Xj . A query with highest possible cautiousness is called no-risk query.
Definition 6 (Elimination Rate). Given a query Xi and the corresponding answer ai 2 fyes; nog, the elimination rate e(Xi; ai) is defined as follows: 8 jDiN j if ai = yes < jDj e(Xi; ai) =
: jDjDiPjj if ai = no The answer ai to a query Xi is called favorable iff it maximizes the elimination rate e(Xi; ai). Otherwise ai is called unfavorable.
So, the cautiousness caut (Xi) of a query Xi is exactly the minimal elimination rate, i.e. caut (Xi) = e(Xi; ai) given that ai is the unfavorable query result. Intuitively, the userdefined cautiousness c is the minimum proportion of diagnoses in D which should be eliminated by the successive query. For braver queries the interval between minimum and maximum elimination rate is larger than for more cautious queries. For no-risk queries it is minimal.
Definition 7 (High-Risk Query). Given a query Xi and cautiousness c, then Xi is called a high-risk query iff caut (Xi) < c, i.e. the cautiousness of the query is lower than the algorithm’s current cautiousness value c. Otherwise, Xi is called non-highrisk query. By HRc(X) X we denote the set of all high-risk queries w.r.t. c. For given cautiousness c, the set of all queries X can be partitioned in high-risk queries and non-high-risk queries.
Given a user’s answer as to a query Xs, the cautiousness c is updated depending on the elimination rate e(Xs; as) by c c + cadj where cadj := 2 (c c)adj denotes the cautiousness adjustment factor. The factor 2 (c c) is a scaling factor that simply regulates the extent of the cautiousness adjustment depending on the interval length c c. The more crucial factor in the formula is adj which indicates the sign and magnitude of the cautiousness adjustment.
k adj :=
e(Xs; as) j jDj 2 jDj where 2 (0; 12 ) is a constant which prevents the algorithm from getting stuck in a nnoo--rriisskk qsturearteygey(Xfosr;eavse)n=jD12j.rEes.gu.l,tignigveanlwcay=s i0n:5aadjnd= 0. The value of can be set to = 0, the elimination rate of a an arbitrary real number, e.g. := 41 . If c + cadj is outside the user-defined cautiousness interval [c; c], it is set to c if c < c and to c if c > c. Positive cadj is a penalty telling the algorithm to get more cautious, whereas negative cadj is a bonus resulting in a braver behavior of the algorithm.
The RIO algorithm, described in Algorithm 2, starts with the computation of
minimal diagnoses. GETDIAGNOSES function implements a combination of hitting-set
(HSTree) [
Then the GETPROBABILITIES function calculates the fault probabilities p(Di) for
each diagnosis Di of the set of leading diagnoses D according to [
Otherwise, GETALTERNATIVEQUERY selects the query Xalt 2 X (Xalt 6= Xsc ) which has minimal score scent among all least cautious non-high-risk queries Lc. That is, Xalt = arg minXk2Lc (scent(Xk)) where Lc = fXr 2 X n HRc(X) j 8Xt 2 X n HRc(X) : caut (Xr) caut (Xt)g. If there is no such query Xalt 2 X, then Xsc is selected. Given the positive answer of the oracle, the selected query Xs 2 fXsc ; Xalt g is added to the set of positive test cases P or, otherwise, to the set of negative test cases N . In the last step of the main loop the algorithm updates the cautiousness value c (function UPDATECAUTIOUSNESS) as described above.
Before the next query selection iteration starts, a stop condition test is performed. The algorithm evaluates whether the most probable diagnosis is at least % more likely than the second most probable diagnosis (ABOVETHRESHOLD) or none of the leading diagnoses has been eliminated by the previous query, i.e.GETELIMINATIONRATE returns zero for Xs. In case that one of the stop conditions is fulfilled, the presently most likely diagnosis is returned (MOSTPROBABLEDIAG).
The main points we want to show in this evaluation are: On the one hand, independently of the specified meta information, RIO exhibits superior average behavior compared to entropy-based method and split-in-half w.r.t. the amount of user interaction required. On the other hand, we want to demonstrate that RIO scales well and that the reaction time measured is well suited for an interactive debugging approach.
As data source for the evaluation we used problematic real-world ontologies produced by ontology matching systems.4 This has the following reasons: (1) Matching results often cause inconsistency and/or incoherency of ontologies. (2) The (fault) structure of different ontologies obtained through matching generally varies due to different authors and matching systems involved in the genesis of these ontologies. (3) For the same reasons, it is hard to estimate the quality of fault probabilities, i.e. it is unclear which of the existing query selection strategies to chose for best performance. (4) Available reference mappings can be used as correct solutions of the debugging procedure.
Matching of two ontologies Oi and Oj is understood as detection of
correspondences between matchable elements of these ontologies. An ontology matching
operation determines an alignment Mij , which is a set of correspondences, i.e. tuples of
the form hxi; xj ; r; vi, where xi 2 Q(Oi), xj 2 Q(Oj ), Q(O) is the set of matchable
elements of an ontology O, r is a semantic relation and v 2 [0; 1] is a confidence value.
We call OiM j := Oi [ Mij [ Oj the aligned ontology for Oi and Oj . In our approach
the elements of Q(O) are restricted to atomic concepts and roles and r 2 fv; w; g
under the natural alignment semantics [
diagnoses can be restricted elegantly depending on the prior knowledge about Dt, which can greatly reduce the complexity of the underlying diagnosis problem.
In [
In our experiments we set the prior fault probabilities as follows: p(axk) := 0:001 for ax k 2 Oi [ Oj and p(ax m) := 1 vm for ax m 2 Mij , where vm is the confidence of the correspondence underlying ax m. Note that this choice results in a significant bias towards diagnoses which include axioms from Mij . Based on these settings, in the first experiment (EXP-1), we simulated an interactive debugging session employing split-in-half (SPL), entropy (ENT) and RIO algorithms, respectively, for each ontology OiM j . Throughout all experiments, we performed module extraction before each test run, which is a standard preprocessing method for ontology debugging approaches. All tests were executed on a Core-i7 (3930K) 3.2Ghz, 32GB RAM and with Ubuntu Server 11.04 and Java 6 installed. The user-chosen parameters were set as follows: jDj := 9 (proved to be a good trade-off between computational complexity for query generation and approximation of all minimal diagnoses), := 85%, c := 0:25 and [c; c] := [cmin; cmax] = [0; 49 ]. For the tests we considered the most general setting, i.e. Dt OiM j . So, we did not restrict the search for Dt to Mij only, simulating the case where the user has no idea whether any of the input ontologies Oi; Oj or the alignment Mij or a combination thereof is faulty. In each test run we measured the number of required queries until Dt was identified. In order to simulate the case where the fault includes at least one axiom ax 2 OiM j n Mij , we implemented a second test session with altered Dt. In this experiment (EXP-2), we precalculated a maximum of 30 most probable minimal diagnoses, and from these we selected the diagnosis with the highest number of axioms ax k 2 OiM j n Mij as Dt in order to simulate more unsuitable meta information. All the other settings were left unchanged. The queries generated in the tests were answered by an automatic oracle by means of the target ontology OiM j n Dt. The average metrics for the set of aligned ontologies OiM j per matching system were as follows: 312 377 and 19:1 28:4.
jMij j jOiM j j
EXP-1 EXP-2 EXP-3 EXP-4 qSPL < qENT 11% 37% 0% 29% qENT < qSPL 82% 56% 100% 71% qSPL = qENT 7% 7% 0% 0% qRIO < min 4% 26% 29% 71% qRIO min 74% 74% 100% 100%
In order to analyze the scalability of RIO, we used the set of ontologies from the
ANATOMY track in the Ontology Alignment Evaluation Initiative6 (OAEI) 2011.5,
which comprises two input ontologies O1 (Human, 11545 axioms) and O2 (Mouse,
4838 axioms). The size of the alignments generated by 12 different matching systems
was between 1147 and 1461 correspondences. Note that the aligned ontologies output
by five matching systems, i.e. CODI, CSA, MaasMtch, MapEVO and Aroma, could
not be analyzed in the experiments. This was due to a consistent output produced by
CODI and the problem that the reasoner was not able to find a model within acceptable
time (2 hours) in the case of CSA, MaasMtch, MapEVO and Aroma. Similar reasoning
problems were also reported in [
Results of both experimental sessions, hEXP-1,EXP-2i and hEXP-3,EXP-4i, are summarized in Figure 2(a) and Figure 2(b), respectively. For the ontologies produced by each of the matching systems and for the different experimental scenarios, the figures show the (average) number of queries asked by RIO and the (average) differences to the number of queries needed by the per-session better and worse strategy of SPL and ENT, respectively. The results illustrate clearly that the average performance achieved by RIO was always substantially closer to the better than to the worse strategy. In both EXP-1 and EXP-2, throughout 74% of 27 debugging sessions, RIO worked as efficiently as the best strategy (Figure 1(a)). In more than 25% of the cases in EXP-2, RIO even
7 For all details w.r.t. hEXP-3,EXP-4i, see http://code.google.com/p/rmbd/wiki/ OntologyAlignmentAnatomy. outperformed both other strategies; in these cases, RIO could save more than 20% of user interaction on average compared to the best other strategy. In one scenario involving OWL-CTXmatch in EXP-1, it took ENT 31 and SPL 13 queries to finish, whereas RIO required only 6 queries, which amounts to an improvement of more than 80% and 53%, respectively. In hEXP-3,EXP-4i, the savings achieved by RIO were even more substantial. RIO manifested superior behavior to both other strategies in 29% and 71% of cases, respectively. Not less remarkable, in 100% of the tests in EXP-3 and EXP-4, RIO was at least as efficient as the best other strategy. Table 1, which provides the average number of queries per strategy, demonstrates that, overall, RIO is the best choice in all experiments. Consequently, RIO is suitable for both good meta information as in EXP-1 and EXP-3, where Dt has high probability, and poor meta information as in EXP-2 and EXP-4, where Dt is a-priori less likely. Additionally, Table 1 illustrates the (average) overall debugging time assuming that queries are answered instantaneously and the reaction time, i.e. the average time between two successive queries. Also w.r.t. these aspects, RIO manifested good performance. Since the times consumed by either of the strategies in hEXP-1,EXP-2i are almost negligible, consider the more meaningful results obtained in hEXP-3,EXP-4i. While the best reaction time in both experiments was achieved by SPL, we can clearly see that SPL was significantly inferior to both ENT and RIO concerning the user interaction required and the overall time. RIO revealed the best debugging time in EXP-4, and needed only 2:2% more time than the best strategy (ENT) in EXP-3. However, if we assume the user being capable of reading and answering a query in, e.g., half a minute on average, which is already quite fast, then the overall time savings of RIO compared to ENT in EXP-3 would already account for 5%. Doing the same thought experiment for EXP-4, using RIO instead of ENT and SPL would save 25% and 50% of debugging time on average, respectively. All in all, the measured times confirm that RIO is well suited as interactive debugging method.
For SPL and ENT strategies, the difference w.r.t. the number of queries per test run between the better and the worse strategy was absolutely significant, with a maximum of 2300% in EXP-4 and averages of 190% to 1145% throughout all four experiments, measured on the basis of the better strategy (Figure 1(b)). Moreover, results show that the different quality of the prior fault probabilities in {EXP-1,EXP-3} compared to {EXP-2,EXP-4} clearly affected the performance of the ENT and SPL strategies (see first two rows in Figure 1(a)). This perfectly motivates the application of RIO. 12,00 10,00 8,00 q 6,00 4,00 2,00 0,00
EXP-1 EXP-2 (a) HMatch
Falcon-AO OWL-Ctxmatch COMA++ 45,00 40,00 35,00 30,00 q 2205,,0000 15,00 10,00 5,00 0,00
EXP-3 EXP-4 (b) Fig. 2. The bars show the avg. number of queries (q) needed by RIO, grouped by matching tools. The distance from the bar to the lower (upper) end of the whisker indicates the avg. difference of RIO to the queries needed by the per-session better (worse) strategy of SPL and ENT, respectively. 5
We have shown problems of state-of-the-art interactive ontology debugging strategies w.r.t. the usage of unreliable meta information. To tackle this issue, we proposed a learning strategy which combines the benefits of existing approaches, i.e. high potential and low risk. Depending on the performance of the diagnosis discrimination actions, the trust in the a-priori information is adapted. Tested under various conditions, our algorithm revealed an average performance superior to two common approaches in the field w.r.t. required user interaction. In our evaluation we showed the utility of our approach in the important area of ontology matching, its scalability and adequate reaction time allowing for continuous interactivity.