RdfRules is a framework for mining logical rules from RDFstyle knowledge graphs. The system provides software support for the complete data mining work ows over RDF data: data ingestion, aggregation, transformations, actual rule mining and post-processing of discovered rules, including clustering. As a rule mining algorithm, RdfRules adopts AMIE+ (Galarraga et al, 2015), which has been extended with number of practical features, such as mining across multiple graphs, topk approach and the ability to de ne ne-grained patterns to reduce the size of the search space. RdfRules is a work-in-progress.
Finding interesting interpretable patterns in data is a frequently performed task
in modern data science work ow. Software for nding association rules, a speci c
form of patterns, is present in nearly all data mining software bundles. These
implementations are based on the apriori algorithm or its successors, which are
severely constrained with respect to the shape of analyzed data { only single
tables or transactional data are accepted. Algorithms for logical rule mining
developed within the scope of Inductive Logical Programming (ILP) do not
have these restrictions, but they typically require negative examples and do not
scale to larger knowledge bases [
Large knowledge bases consisting of linked and machine-readable data are
currently typically published using the RDF1 data representation [
The current state-of-the-art approach for rule mining from RDF knowledge
graphs is the AMIE+ algorithm [
hasChild(a; c) ^ hasChild(b; c) ) isM arriedT o(a; b) The atom has just one speci ed predicate and two variables at the subject and object positions. One of these variables can also be replaced by some speci c constant, e.g., hasChild(a; Carl).
In this paper we describe the RdfRules framework, which uses AMIE+ as a basis for a complete solution for linked data mining. RdfRules adds preprocessing and post-processing capabilities, such as discretization of numerical attributes and clustering of the output rules. Furthermore, RdfRules provides several extensions over AMIE+, such as mining across multiple graphs, rule patterns, constraints, additional measures, top-k approach etc. The framework o ers several ways to control mining processes either through a Scala and Java API, or through a REST web service with a graphical user interface.
This paper is organized as follows. Section 2 provides an overview of the architecture. Section 3 gives details on the implementation. A use case demonstrating a practical application of the system is presented in Section 4. Similar frameworks and other approaches are mentioned in Section 5. The conclusions summarizes the contribution and provides an outlook for future work. 2
An overview of data mining processes as implemented in RdfRules is shown in
Fig. 1b.
The construction and the sequence of individual processes have been inspired by
the CRISP-DM methodology [
Data understanding and preparation. As the rst step, RdfRules loads the input RDF knowledge graph. The framework o ers several functionalities for data aggregation and analysis, such as computation of statistics on triples and their types. Informed by the performed analysis, in this stage, the user can also de ne transformations that are carried on the input RDF data.
Data modeling. In the modeling phase, the user restricts the search space for AMIE+, by de ning pruning thresholds, rule patterns and possibly other constraints. Subsequently, the rule mining process is started and a complete set of found rules is obtained.
Evaluation. A critical phase in rule mining is sifting through the discovered rules to nd the true \nuggets", rules that are of interest to the user. To support this, RdfRules allows the user to lter, sort, select and export interesting extracted rules based on number of features, including measures of signi cance (such as support, con dence and lift). There is also the option to cluster rules by their similarities. 2.2
As Fig. 2 shows the architecture of the RdfRules core is composed of four main data abstractions: RdfGraph, RdfDataset, Index and RuleSet. Instances of these 2.3
The RdfGraph object is built once we load an RDF graph. It can either be a le or a stream of triples or quads in a standard RDF format such as N-Triples, N-Quads, JSON-LD, TriG or TriX. Besides these standard formats the RdfRules framework has its own native binary format to save/cache all de ned data objects and transformations on a disk for later and repeated use. During the data loading process just one RdfGraph instance is created with a default or speci ed name. If the input data format supports named graphs, several instances can be created.
Any RdfGraph instance can be used as a set of triples with multiple transformation operations supported on them. One can lter triples by a condition, replace selected resources or literals and merge numeric data by discretization algorithms. Transformed data may be exported to a le in one of the RDF formats. For analytical purposes, the user can aggregate statements and view statistics or meta information about the graph such as types of predicate ranges or histograms of triple items. The complete list of all important operations is shown in Table 1.
The RdfDataset instance is created from one or many RdfGraph instances. It is composed of quads, where all triples have additional provenance information attached that expresses to which graph they belong. In addition to some extensions the RdfDataset object supports the same operations as the RdfGraph abstraction (see Table 2). Before mining the input dataset has to be indexed into memory for the fast rules enumeration and measures counting. The AMIE+ algorithm uses six fact indexes that hold data in several hash tables. Hence, it is important to realize that the complete input data are replicated six times and then stored into memory before the mining phase. This index may have two modes: preserved and in-use. The preserved mode keeps data in memory until the existence of the index object, whereas the in-use mode loads data into memory only if the index is needed and is released after use.
The Index instance can be created from the RdfDataset object or loaded from cache. It contains prepared data and has operations for rule mining with the AMIE+ algorithm (see Table 3). The AMIE+ algorithm outputs all rules matching the speci ed minimum values of selected measures of signi cance. This can output many more rules than desirable for the user, who may be, for example, interested only in rules that contain a speci c attribute, or may want to prefer to see only the rst 100 rules, rather than wait for the state space to be exhaustively searched. RdfRules addresses these user requirements by extending AMIE+ with the possibility to de ne new types of restrictions: new thresholds, rule patterns and constraints. These are described in greater detail in the following.
Thresholds. Besides standard thresholds de ned in AMIE+, such as support and head coverage, RdfRules also o ers the top-k approach and a timeout threshold which determines a maximum mining time. All mining thresholds are listed in Table 4.
Rule Patterns. RdfRules allows the user to specify several rule patterns using a pre-de ned grammar. All rules must match at least one pattern from the rule pattern list. Matching is performed during the mining phase and therefore the rules enumeration can be greatly sped up thanks to stricter pruning of the state space.
AnyConst(AnyV ar; AnyV ar) ) livesIn(AnyV ar; AnyV ar) wasBornIn(a; b) ) livesIn(a; b) (a rule pattern) (a matching rule) sortBy(measures) computePcaCon dence
(minPcaConf ) computeLift(minConf ) ndSimilar(rule, n), ndDissimilar(rule, n) computeCon dence
(minConf ) take(n), drop(n), slice(from, until ) lterByPatterns (patterns)
Constraints. Finally, the last mining parameter speci es additional constraints and de nes a way of mining. Here is a list of implemented constraints that can be used: { OnlyPredicates(x): rules must contain only predicates de ned in the set x. { WithoutPredicates(x): rules must not contain predicates de ned in the set x. { WithInstances : enable to mine rules with constants at the subject or object position. { WithObjectInstances : enable to mine rules with constants only at the object position. { WithoutDuplicitPredicates : rules that contain one predicate more than once will be removed. The RuleSet object is on the output of the RdfRules work ow. It contains all discovered rules conforming to the restrictions.
Every rule in the rule set consists of the head (consequent - the right side of the rule), body (antecedent - the left side of the rule) and measures2 of signi cance. Basic measures are: rule length, support, head size and head coverage. Other measures may be calculated individually and explicitly within the RuleSet abstraction. Additional measures of signi cance include: body size, con dence, PCA body size, PCA con dence, head con dence, lift and cluster. Rules can be ltered and sorted by all these measures.
This nal abstraction has multiple operations for rule analysis, counting additional measures of signi cance, rule ltering and sorting, rule clustering, and nally rule exporting for use in other systems (see Table 5). All the discovered rules are stored in memory but as in the case of previous data objects all transformations de ned in the RuleSet are lazy. Therefore, this abstraction also allows to cache rules and transformations on a disk or in memory for a repeating usage. The complete rule set (or its subsets) can be exported and saved into a le in a human readable text format or in a machine readable JSON format. 3
The core of RdfRules is written in the Scala language. Besides the Scala API, RdfRules also provides a Java API, REST web service and graphical user interface (GUI) via a web browser (see Fig. 3). The Scala or Java API can be used as a framework to extend another data mining system or application. The 2 All measures of signi cance are described in the AMIE+ paper and on the RdfRules GitHub page: https://github.com/propi/rdfrules web service is suitable for modular web-based applications and remote access. Finally, the GUI is based on the web service interface and can be used either as a standalone desktop application or as a web interface to control an RdfRules instance that is deployed on a remote server.
For RDF data processing RdfRules uses some modules from Apache Jena3
framework. In the pre-processing phase, it is possible to use several
discretization methods for automatic merging of numerical literals. These tasks represent
facades for unsupervised discretization algorithms, such as equal-frequency and
equal-width [
The source code of RdfRules is published under the GPLv3 open-source license5 and is hosted at GitHub6. Detailed manuals for using and deploying individual modules are described on the GitHub page. 4
Examples
Subsets of YAGO [
First, consider only the YAGO sample as the input knowledge graph. We can start the rule mining process simply by invoking several operations in the Scala API:
Scala API: rule mining with default parameters Notice that RdfRules automatically recognized the RDF format by the le extension. In this example the program rst mines all rules conforming to all default restrictions. After that, it sorts rules by the head coverage and takes top three rules from the whole list.
The third output rule directed(a; b) ) actedIn(a; b) can be interpreted as follows: if someone directs something, e.g., a movie, then he or she is also acted in the movie. For this rule there are 4919 triples matching the head actedIn(a; b), it is called head size. Only 60 triples of 4919 are connected to such triples that are matching the body directed(a; b). In other words, there are only 60 cases of 4919 where an actor of a movie is also the director of the movie. This measure 3 https://jena.apache.org/ 4 https://github.com/KIZI/EasyMiner-Discretization 5 https://www.gnu.org/licenses/gpl.txt 6 https://github.com/propi/rdfrules is called support. A ratio between support and head size is called head coverage. For this example the head coverage is
This calculation may be sped-up by using the top-k approach, which returns the same results, but can be faster owing to gradual increase of the support threshold during mining.
Scala API: rule mining with top-k approach Dataset("yago.tsv") .mine(Amie().addThreshold(Threshold.TopK(3))) .sorted
We can also compute additional measures of signi cance, such as con dence, PCA con dence (they indicate the quality of the rule) and lift (it indicates dependence between the body and the head). Similar output rules can be clustered by their similarity functions and the DBscan algorithm:
Scala API: rule mining with other measures
In the next example, we attach the DBpedia knowledge graph and trace such rules whose atoms belong to both graphs. This can be achieved by adding a rule pattern, which restricts the output rule set.
Scala API: rule mining across two graphs (Dataset() + Graph("yago", "yago.tsv") + Graph("dbpedia", "dbpedia.ttl")) .mine(Amie() .addPattern(AtomPattern(graph = Uri("dbpedia")) =>: AtomPattern(graph = Uri("yago"))) .addPattern(AtomPattern(graph = Uri("yago")) =>: AtomPattern(graph = Uri("dbpedia")))) .graphBasedRules //attach a graph to all atoms of all rules //Output samples: hasChild(a, c, <yago>) ^ parent(c, b, <dbpedia>) => isMarriedTo(a, b, <yago>) hasChild(c, a, <yago>) ^ hasChild(c, b, <yago>) => relative(a, b, <dbpedia>) hasNeighbor(a, c, <yago>) ^ spokenIn(b, c, <dbpedia>) => hasOfficialLanguage(a, b, <yago>)
All previous operations can also be performed using the Java API, web service and GUI. The following example shows a complex mining work ow in all available interfaces including pre-processing, rule mining, rules post-processing and exporting results to a le. Figure 4 shows a preview of de ning individual processes in the GUI. Dataset .fromFile("yago.tsv") .filter(quad -> !quad.getTriple().getPredicate().hasSameUriAs("participatedIn")) .discretize(new DiscretizationTask.Equifrequency(3),
quad -> quad.getTriple().getPredicate().hasSameUriAs("hasNumberOfPeople")) .mine(RulesMining.amie() .withInstances(true) .addPattern(RulePattern.create().prependBodyAtom(
new AtomPattern().withPredicate(new Uri("hasNumberOfPeople")))) .addPattern(RulePattern.create(
new AtomPattern().withPredicate(new Uri("hasNumberOfPeople"))))) .computePcaConfidence(0.5) .sorted() .export("rules.json")
Web Service: JSON task definition f "name": "LoadDataset", "parameters": f "path": "yago.tsv" g g, f "name": "FilterQuads", "parameters": f
"or": [f "predicate": "<participatedIn>", "inverse": true g] gg, f "name": "Discretize", "parameters": f "task": f "name": "EquifrequencyDiscretizationTask", "bins": 3 g, "predicate": "<hasNumberOfPeople>" gg, f "name": "Mine", "parameters": f "constraints": ["WithInstancesOnlyObjects"], "patterns": [f
"head": f "predicate": f "name": "Constant", "value": "<hasNumberOfPeople>" g g g,f
"body": [f "predicate": f "name": "Constant", "value": "<hasNumberOfPeople>" g g] g] gg, f "name": "ComputePcaConfidence", "parameters": f "min": 0.5 g g, f "name": "Sorted", "parameters": null g, f "name": "ExportRules", "parameters": f "path": "rules.json" g g
Additional examples demonstrating the three available interfaces for RdfRules: Scala API, Java API, and the web service can be found in the RdfRules GitHub repository.7 5
The RdfRules framework is partially built on the EasyMiner.eu data mining
system [
Another system for RDF data processing is called SANSA-Stack [
Beside the state-of-the-art AMIE+ approach there are other algorithms and
prototypes which come with new measures or methods. First, the SWARM
algorithm, proposed by Barati et al. in [
RdfRules is a software system providing an end-to-end solution for rule mining
over RDF knowledge graphs, implementing the state-of-the-art AMIE+ [
As to the work-in-progress and future work, we currently work on benchmarking RdfRules to evaluate the impact of the the new type of state space restrictions introduced in RdfRules on processing time. A promising direction for extending RdfRules is adding support for RDF schemas and ontologies, which would involve resource types with hierarchies into the mining process. Although the system currently supports multi-threading on a single machine, we would also like to add support for distributed mining and memory scaling on multiple nodes. Finally, AMIE+ produces logical rules with possibly complex structure, which may be found di cult to understand by some users. From the user perspective, research into human-perceived interpretability of logical rules is urgently needed. 7
This research was partly supported by grant IGA 33/2018 and institutional support for research activities of the Faculty of Informatics and Statistics, University of Economics, Prague. 8 https://www.mpi-inf.mpg.de/departments/databases-and-informationsystems/research/yago-naga/amie/