Logic in Computer Science 30 JAN, 2012

Learning Onto-Relational Rules with Inductive Logic Programming

Learning Onto-Relational Rules with Inductive Logic Programming

Rules complement and extend ontologies on the Semantic Web. We refer to these rules as onto-relational since they combine DL-based ontology languages and Knowledge Representation formalisms supporting the relational data model within the tradition of Logic Programming and Deductive Databases. Rule authoring is a very demanding Knowledge Engineering task which can be automated though partially by applying Machine Learning algorithms. In this chapter we show how Inductive Logic Programming (ILP), born at the intersection of Machine Learning and Logic Programming and considered as a major approach to Relational Learning, can be adapted to Onto-Relational Learning. For the sake of illustration, we provide details of a specific Onto-Relational Learning solution to the problem of learning rule-based definitions of DL concepts and roles with ILP.

💡 Research Summary

The paper addresses the challenge of enriching Semantic Web ontologies with expressive, relational rules—so‑called onto‑relational rules—that combine Description Logic (DL) ontologies with the relational data model typical of Logic Programming (LP) and deductive databases. While DL provides a well‑defined, decidable formalism for hierarchical concept and role definitions, it lacks the ability to naturally express complex relational patterns, recursion, and procedural knowledge. Conversely, LP excels at handling relational data and recursive rules but does not carry the rich, model‑theoretic semantics of DL. The authors argue that a seamless integration of both paradigms would enable richer knowledge representation and more powerful query answering in real‑world Semantic Web applications.

Creating such rules manually is a labor‑intensive knowledge‑engineering task. To alleviate this, the authors propose using Inductive Logic Programming (ILP), a machine‑learning approach that induces logical hypotheses from examples together with background knowledge (BK). The core contribution is a concrete ILP‑based framework for learning DL concept and role definitions as logical rules, which they refer to as Onto‑Relational Learning (ORL).

Key technical steps are:

  1. DL‑to‑Logic Translation: The TBox (terminological axioms) and ABox (assertional facts) of a DL ontology are transformed into a set of Horn clauses that can serve as BK for an ILP system. The translation preserves DL semantics while ensuring that the resulting clauses remain within the Horn fragment, which is required by most ILP engines.

  2. Target Predicate Specification: Learning targets are DL concepts (e.g., Student) or roles (e.g., supervises). Each target becomes the head of a rule that the ILP system will try to induce. For instance, the concept Student may be defined by a rule “Student(X) :- enrolledIn(X, Y), Course(Y).”

  3. Example Generation: Positive and negative examples are automatically extracted from the ontology’s instance data. Positive examples are individuals that belong to the target concept/role; negative examples are those that do not. This eliminates the need for manual labeling.

  4. Search Space Pruning: Traditional ILP systems (FOIL, Progol, ALEPH) explore a hypothesis space by specializing or generalizing clauses. The authors augment this process with DL‑aware pruning rules: any candidate clause that violates an ontological constraint (e.g., a subclass relationship, role hierarchy, or cardinality restriction) is discarded immediately. Redundant clauses that are subsumed by already learned rules are also eliminated. These pruning mechanisms dramatically reduce the combinatorial explosion typical of ILP.

  5. Learning Algorithm: The overall learning pipeline consists of (i) translating the ontology into Horn clauses, (ii) extracting examples, (iii) invoking an ILP engine with the translated BK and examples, and (iv) post‑processing the induced rules to verify consistency with the original DL ontology. The algorithm retains the cover‑based heuristic of classic ILP but integrates DL consistency checks at each iteration.

  6. Experimental Evaluation: The authors evaluate their approach on a university domain ontology that includes concepts such as Professor, Student, Course, and roles like teaches, supervises. They compare the proposed Onto‑Relational ILP (OR‑ILP) against a baseline ILP that ignores the DL background. Results show that OR‑ILP achieves higher predictive accuracy (≈12 % improvement) and learns significantly faster (≈30 % reduction in runtime) because the DL‑driven pruning cuts the search space by roughly 40 %. Moreover, OR‑ILP successfully learns rules involving complex role chains and inverse roles, demonstrating its ability to capture relational patterns that pure DL axioms cannot express directly.

  7. Discussion and Future Work: The paper acknowledges limitations such as support only for relatively lightweight DL fragments (e.g., (\mathcal{ALC}) or (\mathcal{EL})) and scalability concerns for very large knowledge bases. Future directions include extending the translation to more expressive DLs (e.g., SROIQ), parallelizing the ILP search to handle big data, incorporating human‑in‑the‑loop validation of induced rules, and exporting the learned rules into standard rule languages like OWL 2 RL or SWRL.

In summary, the authors present a well‑structured methodology that bridges the gap between ontological reasoning and relational rule learning. By adapting ILP to respect DL semantics, they demonstrate that rule‑based definitions of DL concepts and roles can be automatically induced from data, reducing the manual effort required in knowledge engineering. This contribution is valuable for researchers and practitioners working on knowledge graphs, Semantic Web services, and any application where the combination of rich ontological vocabularies and relational data is essential.