Knowledge Graphs (KGs) are a modern database-meets-knowledge-representation encoding of semistructured data that enables efficient querying and logical deductive reasoning. First-order-logic rules expressed over KGs can offer explainable patterns in the KG and can predict missing facts. Hence such rules are a useful option for representation of predictive models built from KGs as training data.
Typically, when learning logic rules over KGs, there is a difficult tradeoff in selecting a rule language that is adequately expressive for accuracy, predictive power, and compact explainability, but not so expressive that the search space for good rules exceeds computational feasibility. The selection of a rule language imposes a bias on the predictive models that can be learnt.
Many KGs contain schema information, usually in a form of an OWL 1 ontology, describing entity types, class relationships, relation domain and range, cardinality constraints, and so forth. Some rule learners also make use of this information when learning rules [1,2].
We wish to address the problem of learning meaningful, accurate, and expressive rules for openended problems. According to Michalski and Chilausky [3], "open-endedness implies that when we make inductive assertions about some piece of reality, there is no natural limit to the level of detail of descriptions of this reality, to the scope of concepts and operators used in the expressions of these assertions, or to the richness of their forms. " We wish to achieve richness of learnt rules by relaxing the language bias of the rule specification, which allows us to express more complex rules than is possible by the restrictive language biases adopted in related work. This relaxation greatly increases the expressiveness of the rules and makes rule learning challenging given the increasing search space and complexity required to learn rules of such forms. To achieve this, we begin with manually crafted rule templates, that are constructed using expert domain knowledge and explicit ontology information. The rule templates provide human-in-the-loop hints to the automated process of model-building. Templates enable the simultaneous specification of both rule structural forms and rule vocabulary, that is, both the shape of rules and the KG terms to be used. Thus our approach is an expert guided technique, trading-off learning automation vs. rule expressiveness.
The main contributions of our work are the following:
• We propose a relaxed rule specification that allows rules to contain: branches and tree shapes, negated graph patterns (in contrast to negated atoms) and SPARQL2 style filtering (including numerical comparisons, and variable inequality constraints). (Section 3.2) • We define the standard rule quality measures of Rule Support, Standard Confidence and Head
Coverage for the proposed relaxed rules. (Section 3.4) • We use an expert-guided template-based approach to generate multiple rules of similar format, thus minimising the effort needed to separately specify rules that share the same structure. (Sections 3.3 and 3.5)
A benefit of our SPARQL compatibility is that the rule specification can be easily converted to a SPARQL query to directly work with RDF3 KGs stored in RDF Triple Stores such as Virtuoso 4 and GraphDB 5 , thus taking advantage of their inherent query optimisation techniques [4] when evaluating complex rules. We present examples of our relaxed rules defined over the FutureSOILS KG, recently built for the project FutureSOILS: Future Proofing the Soils of Southern and Central NSW from Acidification and Soil Organic Carbon Decline6 to predict the pH response of the soil to various liming techniques adopted by farmers. Rule quality measures (such as Standard Confidence, Head Coverage, Rule Support, Rule Body Support, and Head Support) have been evaluated by issuing SPARQL queries generated from the rule to a Virtuoso triple store. Similarly, when making predictions from the rules, instance tables matching rule head and body patterns are retrieved from the KG by issuing SPARQL SELECT queries which can be generated from the rule specification.
In a separate additional use of this relaxed specification, we have allowed SPARQL style variable binding and projection as well as optional graph patterns in the rule specification (in Section 4), so that it can be used to retrieve tabular data from the KG which can be fed into other machine learning models which require typical tabular data as input. In the FutureSOILS work, such attribute extraction rules have been used to extract tabular data to train numeric prediction models such as Random Forest Regressor to predict soil acidity represented as pH values.
A KG contains a set of RDF triples of the form (𝑠, 𝑝, 𝑜) where 𝑠 is called the subject, 𝑜 the object and 𝑝 the relation (also called predicate in this paper), which we write as 𝑝(𝑠, 𝑜) following the convention of first-order logic. We consider KGs with binary relations of the above form, and unary relations conveniently written as 𝑝(𝑠, 𝑠).
A first-order Horn rule 𝑟 is of the form
where ℎ and 𝑏's are atoms of the form 𝑝(𝑡 1 , 𝑡 2 ) where 𝑝 is a predicate and 𝑡 1 , 𝑡 2 are terms [5]. A term is either a variable, entity or literal value (such as a number, text value, date, etc.). Without loss of generality, we use the term constant to refer to both entities and literal values. The atom ℎ is the head of 𝑟 and the conjunction of atoms 𝑏 1 , … , 𝑏 𝑛 is the body of 𝑟.
For rule learning in KGs, a very restricted class of first-order Horn rules is commonly employed, closed-path (CP) rules, where the body atoms form a continuous path from the subject to the object of the head atom. A CP rule is of the following form
where a predicate (of the head and body atoms) may be interpreted as its inverse with the subject and object bindings swapped and 𝑥 𝑗 's (0 ≤ 𝑗 ≤ 𝑛) can only be variables. The head predicate ℎ may occur in the body. We now recall the closed and connected properties of a rule. A variable is closed if it appears at least twice in the rule. A rule is closed if all the variables in the rule are closed. Two atoms in a rule are connected if they share a variable or constant. A rule is connected if every atom in the rule is connected to another atom. A CP rule is both closed and connected, but not vice versa [5].
Various extensions of CP rules have been proposed and learnt by other rule learners by relaxing the language bias and allowing unary predicates, thereby increasing the expressiveness of the learnt rules. For example, AMIE [6,7,8] can only learn connected and closed rules (which is a relaxation of CP rules) over binary predicates. AnyBURL [9,10,11] limits the occurrence of the variables in the learnt rule to occur at most twice and requires strict variable inequality while allowing entities in limited places. Omran et al. [12] define more general open-path rules by allowing an open variable in the head and the last body atom, but still requiring body atoms to form a continuous path linking each atom to its successive atom. They also define inverse open-path rules to represent branching out patterns (SHACL7 shapes) which are systematically aggregated to generate tree-shaped rules.
Some rule learners have achieved more expressiveness by going beyond first-order Horn rules. For example, allowing negated atoms in the rule body [13], simple comparisons among numeric values [14,15] and dealing with temporal values [16,17] over a temporal KG where every atom has a timestamp [5]. Our proposed rule specification follows the structure of Horn rules in that it doesn't require a continuous path being formed by the body patterns thereby allowing branching and tree shapes, but goes beyond Horn rules by allowing multiple negated graph patterns in the body (in contrast with negated single atoms). It also allows complex numeric filtering and time comparisons while still working on a KG with binary predicates.
We would first like to introduce the context of the FutureSOILS [18] KG used in this study in order to motivate the need for the proposed relaxations. The KG contains information about several farm management units and controlled replicated trials of various management strategies used over several years, as well as measurements of soil characteristics and information about crop rotations and harvest yield. The data was required to conform to pre-determined data guidelines and the KG was modelled according to an ontology designed to match the scope of data available. Due to the abundance of N-ary relation patterns in the input data, the KG adopts the standard design for modelling such N-ary relations in RDF [19]. The complete concept map of the ontology and resources related to this paper is accessible in https://w3id.org/kgcp/SRRS.
Numerical values representing soil and crop data and management techniques were transformed to entity instances with expert guidance, or a frequency based approach when industry-adopted bin intervals were unavailable. For example, soil pH8 values were binned into four intervals as follows [*, 4.5), [4.5, 4.8), [4.8, 5.5), [5.5, *].
In the project's scope, the experts were interested in asking several predictive scenarios and gained insights from the modelled data, such as the following, given a particular method of liming (e.g. application of 3 t/ha of lime to the soil followed by a particular cultivation treatment) and given the starting pH value of the soil, what would be the pH (bin) value of the soil one year later? And also two/three years later?. Additional information may be given in each scenario question, such as: Soil Aluminium %, Carbon %, crops planted, weather data, etc.
The structure of the KG that links to multiple N-ary relations 9 requires rules that can represent branching patterns and can compare numerical and time values. Consider the following example rule presented in natural language: If the starting pH value is between 4.8-5.5 at soil depth 7.5-10.00 cm and the unit was limed at a rate 2.0-3.0 t/ha and cultivated with Low Soil Disturbance, then the pH value 1 year later at the same depth would be 4. 5-4.8. Note that this rule would not have been possible in the other rule learners we have discussed, for e.g. AMIE or AnyBURL does not allow rules with branch and tree shaped structures as we have regarding the farm management unit in this rule (see Table 1 for a comparison of expressiveness capabilities among different learners).
In favour of increased rule coverage, we relax some of the temporal definitions like 1 year to include ±2 months (i.e. 10-14 months later) and consider pH measurements taken within 2 months of liming. Some examples of variations of the same rule are given below:
1. Generalisation by shortening the rule (e.g. disregarding cultivation treatment) 2. Generalisation by replacing an entity with a variable (e.g. suffice to have that any cultivation treatment was given, or that liming occurred irrespective of depth and rate) 3. Variation of the rule by adding a negated sub-string (e.g. requiring that cultivation treatment was not done) 4. Refinement of of the rule by adding a further cultivation related information (e.g. also consider depth of cultivation) 5. Refinement of the rule by adding adding more pre-lime observations (e.g. soil Aluminium percentage, Total Carbon percentage)
See Michalski and Chilausky [3] for a comprehensive list of rule generalisation techniques like this for inductive learning.
We now formally specify our relaxed rule language that can support the increased expressiveness required to model complex rules as described above.
Atoms enclosed by ∼ {…} have the meaning of the SPARQL FILTER NOT EXISTS operator10 over graph patterns (i.e. a negated graph pattern which is not known to exist in the KG) and a rule may contain zero or more negated graph patterns (multiplicity denoted by the Kleene star * ).
The rules also need to be connected, that is, every atom in the rule is connected to another atom by sharing a variable or constant with another atom. Additionally, all atoms within a negated graph pattern need to be connected with another atom in the pattern and at least one atom of the pattern should be connected to an outside atom(s) which is not part of a negated graph pattern. The rule does not necessarily need to be closed, but we require that at least one head variable occurs in a non negated atom(s) of the body.
Rules can optionally contain the additional constructs of BIND 11 and FILTER 12 clauses that need to be SPARQL compatible. FILTER clauses allow us to specify multiple additional constraints not usually supported by traditional rule specifications (such as numerical comparisons, variable inequality constraints, type checking, etc.), allowing greater flexibility to work with existing KGs without introducing additional entity mappings into the KG. BIND clauses can be used for specifying new variable bindings which can be used in FILTER clauses.
These rules are closely related to Tree-shaped rules in Omran et al. [12] and rules with negated atoms in Ho et al. [13]. We have extended the concept of negated atoms to negated graph patterns and we have performed numerical and temporal comparisons using a KG with binary predicates as illustrated in the examples further below.
In bottom-up rule learners such as AnyBurl [11], one way of generalising a rule is by replacing entities with variables [3]. In our work, we take a top-down approach, where we work with a set of template rules and then generate variants of the template by replacing selected variables with all the possible combinations of entities that can appear in the respective rule atoms.
For example, consider the following rule template from FutureSOILS that attempts to predict the soil pH roughly one year following liming. The variables ?𝑚_𝑋, ?𝑚_𝑝𝐻, ?𝑚_𝑙𝑖𝑚𝑒 represent literal values of type xsd:positiveInteger and a relaxed definition of time has been implemented by including numerical comparisons in the FILTER clauses where multiple filtering constraints can be specified. Note the negated graph pattern at the end of the rule which specifies that the unit was limed but not cultivated in this example. To differentiate between variables and constants, the variables in the rule are prefixed with "?". Predicates and entities are in RDF prefixed format. Although the BIND clause is not strictly essential in this example, we show it here to demonstrate its usage.
BIND[(?m_X -?m_lime AS ?gap)] FILTER[(?gap >= 10 && ?gap <= 14), (?m_pH -?m_lime <= 2 && ?m_lime -?m_pH <= 2)] fs-data:pH__(1-5-CaCl2)__PSC(?X,?pH_bin_X) <= fs-onto:hasObservation(?eccmo_X,?X), sosa:observedProperty(?X,fs-data:ObservedProperty-pH), sosa:usedProcedure(?X,fs-data:MoA-1-5-CaCl2), fs-onto:hasDepth(?X, ?d_pH), sosa:phenomenonTime(?X, ?t_X), fs-onto:hasMonthCount(?t_X, ?m_X), fs-onto:hasECCMO(?eccmoByRep_X, ?eccmo_X), rdf:type(?eccmoByRep_X, fs-onto:ECCMObyRep), fs-onto:hasControl(?eccmoByRep_X, ?eccmo_C), fs-onto:hasObservation(?eccmo_C, ?obs_pH), fs-data:pH__(1-5-CaCl2)__PSC(?obs_pH,?pH_bin), fs-onto:hasDepth(?obs_pH, ?d_pH), sosa:phenomenonTime(?obs_pH, ?t_pH), fs-onto:hasMonthCount(?t_pH, ?m_pH), fs-onto:hasObservation(?eccmo_C, ?obs_Al), sosa:phenomenonTime(?obs_Al, ?t_pH), fs-onto:hasDepth(?obs_Al, ?d_pH), fs-data:Aluminium-%-of-Cations__(Calculated)__%__PSC(?obs_Al, ?Al_bin), fs-onto:hasECCMO(?mu_lime, ?eccmo_X), fs-onto:hasTime(?mu_lime, ?t_lime), fs-onto:hasMonthCount(?t_lime, ?m_lime), fs-onto:hasManagement(?mu_lime,?mng_lime), rdf:type(?mng_lime, fs-onto:Management-Amelioration-Lime), fs-data:Lime-Application-Rate__PSC(?mng_lime, ?lr_bin), ~{fs-onto:hasECCMO(?mu_culti, ?eccmo_X), fs-onto:hasTime(?mu_culti, ?t_culti), fs-onto:hasMonthCount(?t_culti, ?m_lime), fs-onto:hasManagement(?mu_culti,?mng_culti), rdf:type(?mng_culti, fs-onto:Management-Amelioration)}
Now, if we replace some of the variables of the above template with the possible combinations of candidate entity values for the variables, we can generate multiple rule variants from the above template. In the FutureSOILS domain, replacing ?𝑝𝐻_𝑏𝑖𝑛_𝑋, ?𝑑_𝑝𝐻, ?𝑝𝐻_𝑏𝑖𝑛, ?𝐴𝑙_𝑏𝑖𝑛, ?𝑙𝑟_𝑏𝑖𝑛 in the above template yielded 6144 rule variants with the head atom containing a variable and a constant. This was done by declaring (predicate, variable name) combinations to be replaced in a JSON file (see Figure 1). The candidate entity values for the variables can be retrieved from the KG itself at the time of generating the rule variants (refer Algorithms 1 and 2).
▷ assuming that 𝑣 will be referred in the the rule atom as 𝑞(𝑡 𝑥 , 𝑣) Append 𝑟 ′ to 𝑟𝑢𝑙𝑒_𝑣𝑎𝑟𝑖𝑎𝑛𝑡𝑠 11: end for return 𝑟𝑢𝑙𝑒_𝑣𝑎𝑟𝑖𝑎𝑛𝑡𝑠 Each rule variant can then be assessed by evaluating rule confidence measures such as Standard Confidence, Head Coverage and Rule Support by issuing SPARQL queries generated from the rule to the KG triple store. This process is parallelised to save time.
We now define standard rule quality measures for our relaxed rules: Rule Support (RS), Standard Confidence (SC) and Head Coverage (HC). All of these measures are calculated over the known KG data as it binds to the body and head of the rule, so that a closed-world assumption is made for this evaluation. RS is a count of the number of distinct facts that the rule predicts correctly and is the numerator when calculating SC and HC. SC measures the proportion of correct predictions wrt all distinct predictions that the rule can make given the body bindings in the KG. Note here that missing predictions and known-false predictions are treated equivalently here. HC measures the proportion of the known facts satisfying the rule head that are correctly predicted by the rule, and gives an indication of the generalisation power of the rule.
Since the existing rule quality measures in the literature are based on more restrictive language biases than ours, we define rule quality measures for our relaxed rules which uses a relaxed language bias. These definitions encompass the traditional rule quality measures [12,8,13] and falls back to the traditional definitions when the same language bias referred in the traditional measures are being used.
Consider the following rule of form ( 3), where we have expanded the atoms to depict the variables and constants subject to the constraints specified above. A predicate is interpreted also as its inverse with the subject and object bindings swapped around.
where ℎ and each 𝑏 is a predicate in the KG. To satisfy the connectedness constraints of the relaxed rule, some terms (𝑡's) will be equal and 𝑡 0 is a closed variable. We denote the set of term equalities as 𝐸 = {(𝑡 𝑥 , 𝑡 𝑦 )|𝑡 𝑥 = 𝑡 𝑦 , 𝑡 𝑥 ∈ 𝑇 , 𝑡 𝑦 ∈ 𝑇 }, where 𝑇 ∈ {𝑡 ′ , 𝑡 0 , … , 𝑡 (2𝑗 𝑚 −1) } (for example, when 𝑡 1 = 𝑡 2 ). We denote the set of constraints defined on 𝑇 specified by the BIND and FILTER statements as 𝐹. Recall that some terms in 𝑇 may be constants.
First, let us consider rules with two closed variables in the rule head, so we have 𝑡 ′ = 𝑡 2𝑛−1 . Since the order of the atoms is irrelevant, without loss of generality, we require the variables in the head to be connected to the first and last non-negated atoms. Definition 3.1 (Quality measures for relaxed rules with two closed variables in the head). Let 𝑟 be a relaxed rule of the form (4) and 𝑡 ′ = 𝑡 2𝑛−1 . Then a pair of constants (𝑒 0 , 𝑒 ′ ) satisfies the body of 𝑟 denoted body 𝑟 (𝑒 0 , 𝑒 ′ ), if there exists constants 𝑒 0 , … , 𝑒 2𝑛−1 in the KG (with 𝑒 ′ = 𝑒 2𝑛−1 ) such that 𝑏 1 (𝑒 0 , 𝑒 1 ), 𝑏 2 (𝑒 2 , 𝑒 3 ), … , 𝑏 𝑛 (𝑒 2𝑛−2 , 𝑒 2𝑛−1 ) are facts in the KG and for each negated graph pattern {∧
where 𝑛 0 = 𝑛), the atoms (predicates and the variable bindings) specified in the entire negated graph pattern does not exist in the KG, subject to the term equalities 𝐸 and constraints 𝐹. Also (𝑒 0 , 𝑒 ′ ) satisfies the head of 𝑟 denoted head 𝑟 (𝑒 0 , 𝑒 ′ ), if ℎ(𝑒 0 , 𝑒 ′ ) is a fact in the KG. The rule support (RS), standard confidence (SC) and head coverage (HC) of 𝑟 are given respectively by 𝑅𝑆(𝑟) = |{(𝑒 0 , 𝑒 ′ ) ∶ body 𝑟 (𝑒 0 , 𝑒 ′ ) and head 𝑟 (𝑒 0 , 𝑒 ′ )}|
Now, let us consider rules with a constant in the rule head. Definition 3.2 (Quality measures for relaxed rules with a constant in the head). Let 𝑟 be a relaxed rule of the form (4) and 𝑡 ′ = 𝑐, where 𝑐 is a constant (either an entity or literal value). Then the constant 𝑒 0 satisfies the body of 𝑟 denoted body 𝑟 (𝑒 0 ), if there exists constants 𝑒 0 , … , 𝑒 2𝑛−1 in the KG such that 𝑏 1 (𝑒 0 , 𝑒 1 ), 𝑏 2 (𝑒 2 , 𝑒 3 ), … , 𝑏 𝑛 (𝑒 2𝑛−2 , 𝑒 2𝑛−1 ) are facts in the KG and for each negated graph pattern {∧ 𝑛 𝑘 𝑗 𝑘 =(𝑛 (𝑘−1) +1) 𝑏 𝑗 𝑘 (𝑒 (2𝑗 𝑘 −2) , 𝑒 (2𝑗 𝑘 −1) )} (in 1 ≤ 𝑘 ≤ 𝑚 where 𝑛 0 = 𝑛), the atoms (predicates and the variable bindings) specified in the entire negated graph pattern does not exist in the KG, subject to the term equalities 𝐸 and constraints 𝐹. Also 𝑒 0 satisfies the head of 𝑟 denoted head 𝑟 (𝑒 0 , 𝑐), if ℎ(𝑒 0 , 𝑐) is a fact in the KG. The rule support (RS), standard confidence (SC) and head coverage (HC) of 𝑟 are given respectively by 𝑅𝑆(𝑟) = |{𝑒 0 ∶ body 𝑟 (𝑒 0 ) and head 𝑟 (𝑒 0 , 𝑐)}|
Finally, let us consider rules with an open variable in the rule head which implies 𝑡 ′ does not occur in the rule body. Definition 3.3 (Quality measures for relaxed rules with an open variable in the head). Let 𝑟 be a relaxed rule of the form (4) and the variable 𝑡 ′ ∉ {𝑡 0 , … , 𝑡 (2𝑗 𝑚 −1) }. Then the constant 𝑒 0 satisfies the body of 𝑟 denoted body 𝑟 (𝑒 0 ), if there exist constants 𝑒 0 , … , 𝑒 2𝑛−1 in the KG such that 𝑏 1 (𝑒 0 , 𝑒 1 ), 𝑏 2 (𝑒 2 , 𝑒 3 ), … , 𝑏 𝑛 (𝑒 2𝑛−2 , 𝑒 2𝑛−1 ) are facts in the KG and for each negated graph pattern {∧
where 𝑛 0 = 𝑛), the atoms (predicates and the variable bindings) specified in the entire negated graph pattern does not exist in the KG, subject to the term equalities 𝐸 and constraints 𝐹. Also 𝑒 0 , satisfies the head of 𝑟 denoted head 𝑟 (𝑒 0 , 𝑒 ′ ), if ℎ(𝑒 0 , 𝑒 ′ ) is a fact in the KG for any constant 𝑒 ′ . The rule support (RS), standard confidence (SC) and head coverage (HC) of 𝑟 are given respectively by 𝑅𝑆(𝑟) = |{𝑒 0 ∶ ∃𝑒 ′ , body 𝑟 (𝑒 0 ) and head 𝑟 (𝑒 0 , 𝑒 ′ )}|
In our experience, we found that the SC and HC which are the most widely adopted rule measures were not sufficient to measure the quality of a rule. For example, a rule that correctly predicts 4 out of 5 times and another rule that correctly predicts 80 out of 100 times would get the same SC value of 0.8 and would not convey the number of instances covered by the body of the rule. Those instances provide the evidence for the confidence, while the number of instances covered by the head indicate the generalisation power of the rule. Hence, we also retain the denominator of SC as Rule Body Support (BS) and the denominator of HC as Head Support (HS), which are related to the sample size of SC and HC respectively.
In Section 3.1, we discussed more examples of rule generalisation and refinement involving rule shortening, extending and considering negated graph patterns. We can think of these variations as different templates. The process of template generation (with example parameter settings for the pH prediction rules in FutureSOILS) and rule generation (as explained in Section 3.3) is given in Figure 2.
In our work, we have generated these rule templates using a custom function which constructively generates rule templates for the pH prediction example presented in Section 3.1. This was done by using variations of a list of relevant questions that the project wanted to answer and considering different input scenarios, such as varying how many months following liming (e.g. 10-14, 22-26, 34-38) do we want to predict the pH?, what other pre-lime observations to consider other than the starting pH (e.g. Al)? and what management combinations of Liming, Cultivation, etc. to consider?, whether to disregard Cultivation or require no Cultivation treatment?, etc.).
Thus our expert-guided template-based approach to generate multiple rules of similar format, minimises the effort needed to separately specify rules that share the same structure.
An extension of the relaxed rules specification can be used for the purpose of attribute extraction, with the introduction of optional patterns, that are optional parts of a graph pattern.
Atoms enclosed by {…} have the meaning of the SPARQL OPTIONAL keyword 13 and a rule may contain zero or more optional patterns (denoted by * ) and can be nested inside other optional patterns. An optional pattern needs to be connected (within the pattern) and at least one atom of the outermost negated graph patterns should be connected to an outside atom(s) which is not part of an optional or negated graph pattern. Nested optional patterns need to be connected to an outer optional pattern. In this form, the head atom may or may not contain an open variable.
Attribute extraction rules can also contain SELECT clauses in addition to the BIND and FILTER clauses. SELECT clauses allow us to declare additional variables to be projected when using attribute extraction rules for training other ML models or data visualisation.
The example below is an attribute extraction rule from the FutureSOILS domain. The rule extracts data to train an off-the-shelf numerical model to predict the soil pH value roughly one year following liming. In contrast to the rule template given in Section 3.3 where we referred to the binned numeric entities, here we refer to the numeric attribute values (for example ?𝑝𝐻_𝑣𝑎𝑙 instead of ?𝑝𝐻_𝑏𝑖𝑛, ?𝐴𝑙_𝑣𝑎𝑙 instead of ?𝐴𝑙_𝑏𝑖𝑛, ?𝑙𝑟_𝑣𝑎𝑙 instead of ?𝑙𝑟_𝑏𝑖𝑛, etc.). Note that the rule head contains the not-closed variable ?𝑝𝐻_𝑣𝑎𝑙_𝑋 that becomes the target value to train models. This example computes the mid-point of the soil depth range as ?𝑑_𝑝𝐻_𝑎𝑣𝑔 and number of months since liming as ?𝑔𝑎𝑝.
SELECT[((?d_pH_to + ?d_pH_from)/2 AS ?d_pH_avg), (?m_X -?m_lime AS ?gap)] BIND[] FILTER[(?m_X -?m_lime >= 10 && ?m_X -?m_lime <= 14), (?m_pH -?m_lime <= 2 && ?m_lime -?m_pH <= 2)] fs-data:pH__(1-5-CaCl2)__ASC(?X,?pH_val_X) <= fs-onto:hasObservation(?eccmo_X,?X), sosa:observedProperty(?X,fs-data:ObservedProperty-pH),
The optional pattern in this example enables extraction of data about limed units that were either cultivated or not. The extension enables simple extraction of tabular data by converting the rule to a SPARQL SELECT query. The attribute rules can be generated constructively similar to rule template generation mentioned in Section 3.5. The process of model training by extracting data using attribute extraction rules is given in Figure 3.
Here we presented our SPARQL-based relaxed rule specification and extended standard rule quality measures. In summary,
• we allow meaningful and more expressive inductive rules to be defined over non-trivial KGs by proposing a relaxed rule specification that allows rules to contain branches and tree shapes, negated graph patterns and SPARQL style filtering which can make numerical and temporal comparisons, • and define generalised rule quality measures of Rule Support, Standard Confidence and Head Coverage in order to evaluate the performance of the proposed relaxed rules.
Our approach has the capacity to represent rules with greater expressiveness over KGs with binary predicates. This expressiveness requirement was driven by large-scale application domain modelling, following recommended ontology design patterns and reusing fragments of popular and standard ontologies. We also proposed an expert-guided rule-template-based learning approach to mitigate the issue of the complexity of the search space resulting from the relaxed language bias. Our approach permits expert domain knowledge about the likely relationships in the ontology to be leveraged in the search for good rules. We further extended our relaxed rule specification to include optional patterns which can be used for attribute extraction from KGs to train other ML models. We have not used the optional patterns in the specification of rule templates and generation of variants. Indeed optional patterns in rules have no effect on the application, prediction and quality measures of rules, but may add explanatory value. Ultimately, our rule language, including both the domain-expert-specifiable templates and the automated rule extensions, is expressed in SPARQL. This can be re-expressed in a more conventional rule language as a Datalog sub-language following the translation by Polleres [20].
Since our contribution is mainly a specification, we assess the expressiveness of our proposed relaxed rules against relevant related work in Table 1. As future work, we hope to extend our use-case scenario of FutureSOILS to include geographic data (such as from TERN 14 ) and adopt our relaxed rule specification to retain compatibility with GeoSPARQL 15 . We also hope to apply our relaxed rules to existing large and complex KGs to demonstrate the scalability of our method and perform a quantitative analysis related to the existing work. We would also like to explore whether large language models could substitute for human domain knowledge to propose initial domain-informed rule templates. N N N N
Learning SHACL shapes [12] Limited N N N
Rules with negated atoms [13] N N N Limited
Rules with numeric comp. [15,14] N Limited N N
Temporal rules [17,16] N N Limited N
Landcare Group and Central West Farming Systems. We are grateful to Pouya Ghiasnezhad Omran for many discussions that influenced our work.
This work was funded by the Australian Government through the National Landcare Program. We thank FarmLink, NSW Department of Primary Industries, Australian National University, Holbrook