Learning Description Logic Ontologies. Five Approaches. Where Do They Stand?

The quest for acquiring a formal representation of the knowledge of a domain of interest has attracted researchers with various backgrounds into a diverse field called ontology learning. We highlight classical machine learning and data mining approaches that have been proposed for (semi-)automating the creation of description logic (DL) ontologies. These are based on association rule mining, formal concept analysis, inductive logic programming, computational learning theory, and neural networks. We provide an overview of each approach and how it has been adapted for dealing with DL ontologies. Finally, we discuss the benefits and limitations of each of them for learning DL ontologies.


Introduction
The quest for acquiring a formal representation of the knowledge of a domain of interest has attracted researchers with various backgrounds and both practical and theoretical inquires into a diverse field called ontology learning [33,30]. In this work, we focus on approaches for building description logic (DL) ontologies assuming that the vocabulary and the language of the ontology to be created are known. The main goal is to find how the symbols of the vocabulary should be related, using the logical constructs available in the ontology language. Desirable goals of an ontology learning process include: 1. the creation of ontologies which are interpretable; expressions should not be overly complex, redundancies should be avoided; 2. the support for learnability of DL expressions formulated in rich ontology languages; 3. efficient algorithms for creating ontologies, requiring a small amount of time and training data; 4. limited or no human intervention requirement; 5. the support for learning in unsupervised settings; 6. handling of inconsistencies and noise.
Other properties such as explainability and trustability may also be relevant for some approaches. Moreover, once the ontology has been created, it needs to be checked, be maintained, and evolve. This means that other reasoning tasks should also be feasible.
Nearly 20 years after the term "ontology learning" was coined by Maedche and Staab [33], it is not a surprise that no approach could accomplish such ambitious and conflicting goals. However, different approaches have addressed some of these goals. We highlight five approaches coming from machine learning and data mining which have been proposed for (semi-)automating the creation of DL ontologies. These are based on association rule mining (ARM) [1], formal concept analysis (FCA) [19], inductive logic programming (ILP) [35], computational learning theory (CLT) [46], and neural networks (NNs) [34].
The adaptations of the approaches to the problem of learning DL ontologies often come with the same benefits and limitations as the original approach. To show this effect, for each of the five approaches, we start by presenting the original proposal and then explain how it has been adapted for dealing with DL ontologies. Before presenting them, we introduce some basic notions.

Definitions
Here we present the syntax and semantics of DLs and basic definitions useful to formalise learning problems.

Description Logic Ontologies
We introduce ALC [3], a prototypical DL which features basic ingredients found in many DL languages. Let N C and N R be countably infinite and disjoint sets of concept and role names. An ALC ontology (or TBox ) is a finite set of expressions of the form C ⊑ D, called concept inclusions (CIs), where C, D are ALC concept expressions built according to the grammar rule C, D ::= A | ¬C | C ⊓ D | ∃r.C with A ∈ N C and r ∈ N R . An EL concept expression is an ALC concept expression without any occurrence of the negation symbol (¬). An EL TBox is a finite set of CIs C ⊑ D, with C, D being EL concept expressions.
The semantics of ALC (and of the EL fragment) is based on interpretations. An interpretation I is a pair (∆ I , · I ) where ∆ I is a non-empty set, called the domain of I, and · I is a function mapping each A ∈ N C to a subset A I of ∆ I and each r ∈ N R to a subset r I of ∆ I × ∆ I . The function · I extends to arbitrary ALC concept expressions as follows: It satisfies a TBox T , in symbols I |= T , iff I satisfies all CIs in T . A TBox T entails a CI α, in symbols T |= α, iff all interpretations satisfying T satisfy α.

Learning Frameworks
By learning we mean the process of acquiring some desired kind of knowledge represented in a well-defined and machine-processable form. Examples are pieces of information that characterise such knowledge, given as part of the input of a learning process. We formalise these relationships as follows.
A learning framework F is a triple (E, L, µ) where E is a set of examples, L is a set of concept representations 1 , called hypothesis space, and µ is a function that maps each element of L to a set of (possibly classified) examples in E. If the classification is into {1, 0}, representing positive and negative labels, then µ simply associates elements l of L to all examples labelled with 1 by l. Each element of L is called a hypothesis. The target representation (here simply called target ) is a fixed but arbitrary element of L, representing the kind of knowledge that is aimed for in the learning process.

Example 1.
To formalise the problem of learning DL ontologies from entailments, one can define the learning framework for a given DL L as (E, L, µ) where E is the set of all CIs C ⊑ D with C, D being L concept expressions; L is the set of all L TBoxes; and µ is a function that maps every L TBox T to the set In the next five sections, we highlight machine learning and data mining approaches which have been proposed for (semi-)automating the creation of DL ontologies. As mentioned, for each approach, we first describe the original motivation and application. Then we describe how it has been adapted for dealing with DL ontologies.

Original Approach
Association rule mining (ARM) is a data mining method frequently used to discover patterns, correlations, or causal structures in transaction databases, relational databases, and other information repositories. We provide basic notions, as it was initially proposed [1].
Definition 2 (Association Rule). Given a set I = {i 1 , i 2 , . . . , i n } of items, and a set D = {t 1 , t 2 , . . . , t m } of transactions (called transaction database) with each t i ⊆ I, an association rule is an expression of the form A ⇒ B where A, B are sets of items.
The task of mining rules is divided into two parts: (i) mining sets of items which are frequent in the database, and, (ii) generating association rules based on frequent sets of items. To measure the frequency of a set X of items in a transaction database D, one uses a measure called support, defined as: If a set X of items has support larger than a given threshold then it is used in the search of association rules, which have the form A ⇒ B, with X = A ∪ B.
To decide whether an implication A ⇒ B should be in the output of a solution to the problem, a confidence measure is used. The confidence of an association rule A ⇒ B w.r.t. a transaction database D is defined as: Essentially, support measures statistical significance, while confidence measures the 'strength' of a rule [1]. We parameterize the ARM learning framework F ARM with the confidence threshold δ ∈ [0, 1] ⊂ R. F ARM (δ) is (E, L, µ) where E is the set of all database transactions D; L is the set of all sets S of association rules; and µ(S) = {D ∈ E | ∀α ∈ S we have that conf D (α) ≥ δ}.

Building DL ontologies
An immediate way of adapting the ARM approach to deal with DL ontologies is to make the correspondence between a finite interpretation and a transaction database. Assume I is a finite interpretation then the notions of support and confidence can be adapted to: The problem of giving logical meaning to association rules is that it may happen that C ⊑ D and D ⊑ E have confidence values above a certain threshold while C ⊑ E does not have a confidence value that is above the threshold, even though it is a logical consequence of the first two CIs [7]. This problem also occurs in the original ARM approach if the association rules are interpreted as Horn rules in propositional logic. To see this effect, consider Example 3. We have that both {Product3, Product4} ⇒ {Product1} and {Product1} ⇒ {Product2} have confidence 75% but the confidence of {Product3, Product4} ⇒ {Product2} is only 50%. Another difficulty in this adaptation for dealing with DLs is that the number of CIs with confidence value above a given threshold may be infinite (consider e.g. EL CIs in an interpretation with a directed cycle) and a finite set which implies such CIs may not exist.
The learning framework here is parameterized with a DL L and a confidence threshold δ ∈ [0, 1] ⊂ R. Then, F DL ARM (L, δ) is (E, L, µ) with E the set of all finite interpretations I; L the set of all L TBoxes T ; and ARM+DL Problem: Given I, L, and δ, let F DL ARM (L, δ) be (E, L, µ). Find T ∈ L with I ∈ µ(T ).
ARM is an effective approach for extracting CIs with concept expressions of fixed length from RDF datasets. Using this technique, e.g., DeputyDirector ⊑ CivilServicePost and MinisterialDepartment ⊑ Department were extracted from data.gov.uk [48,14,47] (see also [43] for expressive DLs with fixed length).
More recently, ARM has been applied to mine relational rules in knowledge graphs [16]. This approach, born in the field of data mining, is relevant for the task of building DL ontologies, as it can effectively find interesting relationships between concept and role names. However, it lacks support for mining CIs with existential quantifiers on the right-hand side [45].

Original Approach
Formal Concept Analysis (FCA) is a mathematical method of data analysis which describes the relationship between objects and their attributes [19] (see also [18] for an introduction to this field). In FCA, data is represented by formal contexts describing the relationship between finite sets of objects and attributes. The notion of a transaction database (Definition 2) is similar to the notion of a formal context (Definition 4).
where G is a set of objects, M is a set of attributes, and I ⊆ G × M is a binary relation between objects and attributes.
A formal concept is a pair (A, B) consisting of a set A ⊆ G of objects (the 'extent') and a set B ⊆ M of attributes (the 'intent') such that the extent consists of all objects that share the given attributes, and the intent consists of all attributes shared by the given objects. A formal concept ( The set of all formal concepts ordered by ≤ forms a complete lattice. Table 2. In FCA, dependencies between attributes are expressed by implications-a notion similar to the notion of an association rule (Definition 2). An implication is an expression of the form B 1 → B 2 where B 1 , B 2 are sets of attributes. An implication B 1 → B 2 holds in a formal context (G, M, I) if every object having all attributes in B 1 also has all attributes in An implication i follows from a set S of implications if any subset of M that respects all implications from S also respects i. In FCA, one is essentially interested in computing the implications that hold in a formal context. A set S of implications that hold in a formal context K is called an implicational base for K if every implication that holds in K follows from S. Moreover, there should be no redundancies in S (i.e., if i ∈ S then i does not follow from S \ {i}). Implicational bases are not unique. A well-studied kind of implicational base (with additional properties) is called stem (or Duquenne-Guigues) base [25,18].
The learning framework for FCA is F FCA = (E, L, µ) with E the set of all formal contexts K; L the set of all implicational bases S; and

Building DL ontologies
Approaches to combine FCA and DL have been addressed by many authors [42,5,4,7,41]. A common way of bridging the gap between FCA and DL [10] is the one that maps a finite interpretation I = (∆ I , · I ) and a finite set S of concept expressions into formal context (G, M, I) in such a way that: -each d ∈ ∆ I corresponds to an object o in G; -each concept expression C ∈ S corresponds to an attribute a in M ; and d ∈ C I if, and only if, (o, a) ∈ I.
The notion of an implication is mapped to the notion of a CI in a DL. Just to give an idea, if the formal context represented by Table 2 is induced by a DL interpretation then the CI Attribute2 ⊑ Attribute1 would be a candidate to be added to the ontology. The notion of an implicational base is adapted as follows. Let I be a finite interpretation and let L be a DL language with symbols taken from a finite vocabulary. An implicational base for I and L [10] is a non-redundant set T of CIs formulated in L (for short L-CIs) such that for all L-CIs We parameterize the learning framework F DL FCA with a DL L.
, where E is the set of all finite interpretations I, L is the set of all implicational bases T for I ∈ E and L, and µ(T )={I ∈ E | T is an implicational base for I and L}.
Similar to the difficulty described for the DL adaptation of the ARM approach, there may be no finite implicational base for a given interpretation and DL. . However, if we remove e 3 from the extension of A, B then, for all n ∈ N, the CI A ⊑ ∃r n .⊤ holds and there is no EL rhs finite base that can entail all such CIs. More expressive languages can be useful for the computation of finite bases. It is known that, for EL with greatest fixpoints semantics, a finite implicational base always exists [10].
Classical FCA and ARM assume that all the information about the individuals is known and can be represented in a finite way. A '✓' in a table representing a formal context means that the attribute holds for the corresponding object and the absence means that the attribute does not hold. In contrast, DL makes the 'open-world' assumption, and so, the absence of information indicates a lack of knowledge, instead of negation. To deal with the lack of knowledge, the authors of [5] introduce the notion of a partial context, in which affirmative and negative information about individuals is given as input and an expert is required to decide whether a given concept inclusion should hold or not.
The need for a finite representation of objects and their attributes hinders the creation of concept inclusions expressing, for instance, that 'every human has a parent that is a human', in symbols Human ⊑ ∃hasParent.Human or 'every natural number has a successor that is a natural number', where elements of a model capturing the meaning of the relation are linked by an infinite chain. This limitation is shared by all approaches which mine CIs from data, including ARM, but in FCA this difficulty is more evident as it requires 100% of confidence. This problem can be avoided by allowing the system to interact with an expert who can assert domain knowledge that cannot be conveyed from the finite interpretation given as input [42].

Original Approach
ILP is an area between logic programming and machine learning [35]. In the general setting of ILP, we are given a logical formulation of background knowledge and some examples classified into positive and negative [35]. We introduce the syntax of function-free first-order Horn clauses. A term t is either a variable or a constant. An atom is an expression of the form P ( t) with P a predicate and t a list of terms t 1 , . . . , t a where a is the arity of P . An atom is ground if all terms occurring in it are constants. A literal is an atom α or its negation ¬α. A first-order clause is a universally quantified disjunction of literals. It is called Horn if it has at most one positive literal. A Horn expression is a set of (first-order) Horn clauses. A classified example in this setting is a pair (e, ℓ(e)) where e is a ground atom and ℓ(e) (the label of e) is 1 if e is a positive example or 0 if it is negative.   Table 3. In this example, one might conjecture a hypothesis H which states that: This form of inference is not sound in the logical sense since H does not necessarily follow from B and S. Another hypothesis considered as correct by this approach would be ∀x(Person(x) → DomainExpert(x)), even though one could easily think of an interpretation with a person not being a domain expert. One could also create a situation in which there are infinitely many hypotheses suitable to explain the positive and negative examples. For this reason, it is often required a non-logical constraint to justify the choice of a particular hypothesis [35]. A common principle is the Occam's razor principle which says that the simplest hypothesis is the most likely to be correct (simplicity can be understood in various ways, a naive way is to consider the length of the Horn expression as a string).
We parameterize the learning framework for ILP with the background knowledge B, given as part of the input of the problem. We then have that ILP Problem: Given B and S (as in Definition 7), let F ILP (B) be (E, L, µ). Find H ∈ L such that H is a correct (and simple) hypothesis for B and S. That is, for all (e, ℓ(e)) ∈ S, e ∈ µ(H) iff ℓ(e) = 1.

Building DL Ontologies
In the DL context, ILP has been applied for learning DL concept expressions [12,13,21,26,29,27] and for learning logical rules for ontologies [31]. We describe here the problem setting for learning DL concept expressions, which can help the designer to formulate the concept expressions in an ontology. As in the classical ILP approach, the learner receives as input some background knowledge, formulated as a knowledge base K = (T , A), where T is a TBox and A is a set of assertions, that is, expressions of the form A(a), r(a, b) where A ∈ N C , r ∈ N R , and a, b are taken from a set N I of individual names. Assertions can be seen as ground atoms and A, in DL terms, is called an ABox. A set S of pairs (e, ℓ(e)) with e an assertion and ℓ(e) ∈ {1, 0} is also given as part of the input. In the mentioned works, e is of the form Target(a), with Target a concept name in N C not occurring in K and a ∈ N I .
As in the original ILP approach, given K = (T , A) and S, a concept expression C (in the chosen DL) is correct for K and S if, for all (Target(a), ℓ(Target(a))) ∈ S, we have that (T ∪ {Target ≡ C}, A) |= Target(a) iff ℓ(Target(a)) = 1. Table 3 can be translated into (T , A), with T = {MedicalDomain ⊑ Domain} and A the set of ground atoms given as background knowledge in Table 3. Assuming that the target concept name is DomainExpert and the set S of classified examples is the one in Table 3, correct concept expressions would be ∃isExpert.Domain and Person.

Example 9. The background knowledge in
The learning framework and problem statement presented here is for learning ALC and EL concept expressions based on the ILP approach [28,29]. Here the learning framework is parameterized by a knowledge base (T , A) and a DL L. ILP+DL Problem: Given K, L, and S (the classified examples), let F DL ILP (K, L) be (E, L, µ). Find C ∈ L such that C is correct (and simple) for K and S. That is, for all (e, ℓ(e)) ∈ S, e ∈ µ(C) iff ℓ(e) = 1.

Original Approach
We describe two classical learning models in CLT which have been applied for learning DL concept expressions and ontologies. We start with the classical PAC learning model and then describe the exact learning model 3 .
In the PAC learning model, a learner receives classified examples drawn according to a probability distribution and attempts to create a hypothesis that approximates the target. The aim is to bound the probability that a hypothesis constructed by the learner misclassifies an example. This approach can be applied to any learning framework. Within this model, one can investigate the complexity of learning an abstract target, such as a DL concept, an ontology, or the weights of a NN.
We now formalise this model. Let F = (E, L, µ) be a learning framework. A probability distribution D over E is a function mapping events in a σ-algebra E of subsets of E to [0, 1] ⊂ R such that D( i∈I X i ) = i∈I D(X i ) for mutually exclusive X i , where I is a countable set of indices, X i ∈ E, and D(E) = 1. Given a target t ∈ L, let EX D F,t be the oracle that takes no input, and outputs a classified example (e, ℓ t (e)), where e ∈ E is sampled according to the probability distribution D, ℓ t (e) = 1, if e ∈ µ(t), and ℓ t (e) = 0, otherwise. An example query is a call to the oracle EX D F,t . A sample generated by EX D F,t is a (multi-)set of indexed classified examples, independently and identically distributed according to D, sampled by calling EX D F,t . A learning framework F is PAC learnable if there is a function f : (0, 1) 2 → N and a deterministic algorithm such that, for every ǫ, δ ∈ (0, 1) ⊂ R, every probability distribution D on E, and every target t ∈ L, given a sample of size m ≥ f (ǫ, δ) generated by EX D F,t , the algorithm always halts and outputs h ∈ L such that with probability at least (1 − δ) over the choice of m examples in E, we have that D(µ(h) ⊕ µ(t)) ≤ ǫ. If the number of computation steps used by the algorithm is bounded by a polynomial function p(|t|, |e|, 1/ǫ, 1/δ), where e is the largest example in the sample generated by EX D F,t , then F is PAC learnable in polynomial time. Assume h, t ∈ L, µ(h) = {♥, }, and µ(t) = {♥, △}. Then, the probability D(µ(h) ⊕ µ(t)) that h misclassifies an example according to D is 0.5.
PAC Problem: Given a learning framework decide whether it is PAC learnable in polynomial time.
In the classical PAC approach, the probability distribution D is unknown to the learner. The algorithm should provide a probabilistic bound for any possible D. We now describe the exact learning model. In this model, a learner tries to identify an abstract target known by a teacher, also called an oracle, by interacting with the teacher [2]. The most successful protocol is based on membership and equivalence queries. As it happens with the PAC learning model, this model can be used to formulate learning problems within the context of any kind of learning framework.
We formalise these notions as follows. Given a learning framework F = (E, L, µ), we are interested in the exact identification of a target concept representation t ∈ L by posing queries to oracles. Let MQ F,t be the oracle that takes as input some e ∈ E and returns 'yes' if e ∈ µ(t) and 'no' otherwise. A membership query is a call to the oracle MQ F,t . For every t ∈ L, we denote by EQ F,t the oracle that takes as input a hypothesis concept representation h ∈ L and returns 'yes' if µ(h) = µ(t) and a counterexample e ∈ µ(h) ⊕ µ(t) otherwise, where ⊕ denotes the symmetric set difference. There is no assumption regarding which counterexample in µ(h) ⊕ µ(t) is chosen by the oracle. An equivalence query is a call to the oracle EQ F,t . In this model, if examples are interpretations or entailments, the notion of 'equivalence' coincides with logical equivalence.
A learning framework F is exactly learnable if there is a deterministic algorithm such that, for every t ∈ L, it eventually halts and outputs some h ∈ L with µ(h) = µ(t). Such algorithm is allowed to call the oracles MQ F,t and EQ F,t . If the number of computation steps used by the algorithm is bounded by a polynomial p(|t|, |e|), where t ∈ L is the target and e ∈ E is the largest counterexample seen so far, then F is exactly learnable in polynomial time.
Exact Problem: Given a learning framework decide whether it is exactly learnable in polynomial time.
In Theorem 11, we recall an interesting connection between the exact learning model and the PAC model extended with membership queries. If there is a polynomial time algorithm for a learning framework F that is allowed to make membership queries then F is PAC learnable with membership queries in polynomial time.
Theorem 11. [2] If a learning framework is exactly learnable in polynomial time then it is PAC learnable with membership queries in polynomial time. If only equivalence queries are used then it is PAC learnable (without membership queries) in polynomial time.
The converse of Theorem 11 does not hold [6]. That is, there is a learning framework that is PAC learnable in polynomial time (even without membership queries) but not exactly learnable in polynomial time.

Building DL Ontologies
The PAC learning model has been already applied to learn DL concept expressions formulated in DL CLASSIC [9,15] (see also [36]). The main difficulty in adapting the PAC approach for learning DL ontologies is the complexity of this task. In the PAC learning model, one is normally interested in polynomial time complexity, however, many DLs, such as ALC, have superpolynomial time complexity for the entailment problem and entailment checks are often important to combine the information present in the classified examples.
It has been shown that the EL fragments EL lhs and EL rhs -the EL fragments that allow only conjunctions of concept names on the right-side and on the left-side of CIs, respectively-are polynomial time exactly learnable from entailments [23,24,38,37] 4 , however, this is not the case for EL. The learning framework is the one in Example 1 and the problem statement is the same as in the original approach. By Theorem 11, the results for EL lhs and EL rhs are transferable to the PAC learning model extended with membership queries. The results show how changes in the ontology language can impact the complexity of searching for a suitable ontology in the hypothesis space. The main difficulty of implementing this model is that it is based on oracles, in particular, on an equivalence query oracle. Fortunately, as already mentioned, such equivalence queries can be simulated by the sampling oracle of the PAC learning model to achieve PAC learnability (Theorem 11) [2].

Original Approach
NNs are widespread architectures inspired by the structure of the brain [34]. They may differ from each other not only regarding their weight and activation functions but also structurally, e.g., feed-forward NNs are acyclic while recurrent NNs have cycles. One of the simplest models is the one given by Definition 12.
Definition 12 (Neural Network). An NN is a triple (G, σ, w) where G = (V, E) is a graph, with V a set of nodes, called neurons, and E ⊆ V × V a set of (directed) edges; σ : R → R is the activation function; and w : E → R is the weight function.
Other parameters that can be part of the definition of an NN are the propagation function and biases. A widely used propagation function is the weighted sum. The propagation function specifies how the outputs of the neurons connected to a neuron n are combined to form the input of n. Given an input to a neuron, the activation function maps it to the output of the neuron. In symbols, the input in(n) of a neuron n is m:(m,n)∈E σ(in(m)) · w((m, n)).
The structure of an NN is organized in layers, basically, an input, an output, and (possibly several) hidden layers. The input of an NN is a vector of numbers in R, given as input to the neurons in the input layer. The output of the NN is also a vector of numbers in R, constructed using the outputs of the neurons in the output layer. The dimensionality of the input and output of an NN varies according to the learning task. One can then see an NN as a function mapping an input vector x to an output vector y. In symbols, (G, σ, w)( x) = y.
The main task is to find a weight function that minimizes the risk of the NN N , modelled by a function L D (N ), with D a probability distribution on a set of pairs ( x, y) of input/output vectors [44]. The risk of an NN represents how well we expect the NN to perform while predicting the classification of unseen examples.
The learning framework can be defined in various ways. Here we parameterize it by a graph structure and an activation function σ. We have that F NN (G, σ), with G = (V, E), is (E, L, µ) where E is a set of pairs ( x, y) representing input and output vectors of numbers in R (respectively, and with appropriate dimensionality); L is the set of all weight functions w : E → R; and One can formulate the NN problem as follows.
NN Problem: Given G and σ, let F NN (G, σ) be (E, L, µ). Find w ∈ L that minimizes the risk L D (N ) of N = (G, σ, w), where D is a fixed but arbitrary and unknown probability distribution on E.
Classified examples for training and validation can be obtained by calling the sampling oracle EX D F,t (recall EX D F,t from Section 6), where t ∈ L is the (unknown) target weight function. One of the main challenges of this approach is that finding an optimal weight function is computationally hard. Most works apply a heuristic search based on the gradient descent algorithm [44].

Building DL Ontologies
NNs have been applied to learn CIs from sentences expressing definitions, called definitorial sentences [39] (see also [32] for more work on definitorial sentences in a DL context, and, e.g. [8,50], for work on learning assertions based on NNs). More specifically, the work on [39] is based on recurrent NNs, which are useful to process sequential data. The structure of the NN, in this case, takes the form of a grid. The authors learn ALCQ CIs, where ALCQ is the extension of ALC with qualified number restrictions. For example, "A car is a motor vehicle that has 4 tires and transport people." corresponds to Car ⊑ MotorVehicle ⊓ = 4has.Tires ⊓ ∃transport.People.
The main benefits of this approach is that NNs can deal with natural language variability. The authors provide an end-to-end solution that does not even require natural language processing techniques. However, the approach is based on the syntax of the sentences, not on their semantics, and they cannot capture portions of knowledge across different sentences [39]. Another difficulty of adapting this approach for learning DL ontologies is the lack of datasets available for training. Such dataset should consist of a large set of pairs of definitorial sentences and their corresponding CI. The authors created a synthetic dataset to perform their experiments.
The learning framework and problem statement for learning DL CIs based on the NN approach [39] can be formulated as follows. The learning framework for a DL L can be defined as F DL NN (G, σ, L) = (E, L, µ) where E is a set of pairs ( x, y) with x a vector representation of a definitorial sentence and y a vector representation of an L CI; and L and µ are as in the original NN approach.
NN+DL Problem: Given G, L and σ, let F DL NN (G, σ, L) be (E, L, µ). Find w ∈ L that minimizes the risk L D (N ) of N = (G, σ, w), where D is a fixed but arbitrary and unknown probability distribution on E.

Where Do They Stand?
We now discuss the main benefits and limitations of ARM, FCA, ILP, CLT, and NNs for building DL ontologies, considering the goals listed in the Introduction.
Interpretability. refers to the easiness of understanding the learned DL ontology/concept expressions and obtaining insights about the domain. In ARM, the requirement for computing CIs with high support often results in highly interpretable CIs (at the cost of fixing the length of concept expressions). The FCA approach classically deals with redundancies, which is often not considered in ARM approaches. However, the CIs generated with this approach can be difficult to interpret [7]. The ILP approach follows the Occam's razor principle, which contributes to the generation of interpretable DL expressions, although there is no guarantee for the quality of the approximation. Such guarantees can be found in CLT, where the goal is to approximate or exactly identify the target. However, the focus of these approaches is on accuracy rather than interpretability. Regarding NNs, the complex models can deal with high variability in the data but may lose on interpretability.
Expressivity. refers to the expressivity of the DL language supported by the learning process. As we have seen, many previous approaches for learning DL ontologies focus on Horn fragments such as EL [23,24,11,28,4,7] (or Hornlike fragments such as FLE [42]). Non-horn fragments have been investigated for learning DL ontologies [48,43] and concept expressions [13,21,29] (fixing the length of concept expressions). As mentioned, ALCQ CIs can be learned with NNs [39] (see also [51]).
Efficiency. refers to the amount of time and memory consumed by algorithms in order to build a DL ontology (or concept expressions) in the context of a particular approach or a learning model. In CLT one can formally establish complexity results for learning problems. In ARM the search space is heavily constrained by the support function, which means that usually large portions of the search space can be eliminated in this approach. The Next-closure algorithm used in FCA is polynomial in the output and has polynomial delay, meaning that from the theoretical point of view it has interesting properties regarding efficiency. However, in practice, there may be difficulties in processing large portions of data provenient of knowledge graphs, such as DBpedia [7].
Human interactions. may be required to complete the information given as input or to validate the knowledge that cannot be represented in a finite dataset or in a finite interpretation (recall the case of an infinite chain of objects in Subsection 4.2). Since the input is simply a database or an interpretation, the ARM and FCA approaches require limited or no human intervention. It is worth to point out that some DL adaptations of the FCA approach depend on an expert which resembles a membership oracle. The difference is that in the exact learning model the membership oracle answers with 'yes' or 'no', whereas in FCA the oracle also provides a counterexample if the answer is 'no' [42]. In ILP, examples need to be classified into positive and negative, which may require human intervention to classify the examples before learning takes place. The same happens with the CLT models presented. The exact learning model is purely based on interactions with an oracle, which can be an expert (or even a neural network [49]).
Unsupervised learning. is supported by the ARM and FCA approaches, as well as some NNs (but not by the DL adaptation we have seen in the literature [39]). As already mentioned, the approaches based on ILP and CLT fall in the supervised setting. That is, examples receive some sort of (usually binary) classification.
Inconsistencies and noise. are often present in the data. The ARM approach deals with them by only requiring that the confidence of the CI is above a certain threshold (instead of requiring that the CI is fully satisfied, as in FCA). ILP and CLT classically do not support inconsistencies and noise, though, the PAC model has an agnostic version in which it may not be possible to construct a hypothesis consistent with the positive and negative examples (due e.g. to noise in the classification). NNs can deal very well with data variability, including cases in which there are inconsistencies and noise.

Conclusion
We discussed benefits and limitations of, namely, ARM, FCA, ILP, CLT, and NNs for DL settings. Not many authors have applied NNs for learning DL ontologies (when the focus is on building the logical expressions), even though NNs are widespread in many areas. We believe that more works exploring this approach are yet to come. One of the challenges is how to capture the semantics of the domain. Promising frameworks for capturing the semantics of logical expressions [17,40] and modelling logical rules [20] have been recently proposed.
Finally, we have seen that each approach addresses some of the desired properties of an ontology learning process. An interesting question is whether they can be combined so as to obtain the best of each approach. Indeed, recent works have proposed ways of combining FCA with the exact and PAC learning models [36]. Moreover, the support and confidence measures from ARM could also be applied in FCA for dealing with noisy and incomplete data [7].