Davide Sottara

Learning Business Rules with Association Rule Classifiers

The main obstacles for a straightforward use of association rules as candidate business rules are the excessive number of rules discovered even on small datasets, and the fact that contradicting rules are generated. This paper shows that Association Rule Classification algorithms, such as CBA, solve both these problems, and provides a practical guide on using discovered rules in the Drools BRMS and on setting the ARC parameters. Experiments performed with modified CBA on several UCI datasets indicate that data coverage rule pruning keeps the number of rules manageable, while not adversely impacting the accuracy. The best results in terms of overall accuracy are obtained using minimum support and confidence thresholds. Disjunction between attribute values seem to provide a desirable balance between accuracy and rule count, while negated literals have not been found beneficial.

A Representational Analysis of the API4KP Metamodel

The API for Knowledge Platforms (API4KP) provides a common abstraction interface for discovery, exploration of metadata and querying of different types of knowledge bases. It targets the basic administration services as well as the retrieval and the modification of expressions in machine-readable knowledge representation and reasoning (KRR) languages, such as RDF(S), OWL, RuleML and Common Logic, within heterogeneous and possibly distributed (multi-language, multi-nature) knowledge platforms. This paper introduces typical use cases for API4KP and, based on their ontological requirements, analyses the representational completeness and clarity of its ontological metamodel.

API4KP Metamodel: A Meta-API for Heterogeneous Knowledge Platforms

API4KP (API for Knowledge Platforms) is a standard development effort that targets the basic administration services as well as the retrieval, modification and processing of expressions in machine-readable languages, including but not limited to knowledge representation and reasoning (KRR) languages, within heterogeneous (multi-language, multi-nature) knowledge platforms. KRR languages of concern in this paper include but are not limited to RDF(S), OWL, RuleML and Common Logic, and the knowledge platforms may support one or several of these. Additional languages are integrated using mappings into KRR languages. A general notion of structure for knowledge sources is developed using monads. The presented API4KP metamodel, in the form of an OWL ontology, provides the foundation of an abstract syntax for communications about knowledge sources and environments, including a classification of knowledge source by mutability, structure, and an abstraction hierarchy as well as the use of performatives (inform, query, ...), languages, logics, dialects, formats and lineage. Finally, the metamodel provides a classification of operations on knowledge sources and environments which may be used for requests (message-passing).

Extending an object-oriented RETE network with fine-grained reactivity to property modifications

Managing rule chaining, especially in presence of recursion, is a common difficulty when authoring rule based applications. For this reason, production systems implement strategies such as refraction to control rule activation repeatability. In this paper, we present a related extension for an object-oriented version of the RETE algorithm, called property-based reactivity. This extension provides additional, finer grained control of repeatable rules, at the object property level. Patterns have control over which properties they will react to: by default, this is properties the pattern constrains on, but additional properties may be included or excluded using appropriate annotations in the rule base. The engine enhancement is based on a compile-time analysis of the rule base that minimizes the overhead on the language and the runtime execution. The correlation between the performance impact due to the strategy and the structure of the rules has been analyzed and benchmarked using an implementation based on the open source rule engine Drools.

Reducing the Cost of the Linear Growth Effect Using Adaptive Rules with Unlinking and Lazy Rule Evaluation

The match cost of Rete [8] increases significantly and approximately linearly with the number of rules [2]. A major part of that cost is the eager creation of cross products within the join nodes in an attempt to materialize rule instantiations. This paper builds on the idea of adaptive rules [1] using the unlinking of nodes, segments of nodes and rules to delay join attempts, which helps mitigate some aspects of the linear growth effect. By delaying the evaluation of a rule until after it’s linked and restricting the propagation to a single path, a lazy goal-driven evaluation behaviour is introduced. The algorithm also preserves node sharing by organising the network into segments and paths of segments; with memory now at node, segment and path levels. This paper presents the design and implementation of this work within the popular Open Source Drools rule engine. Drools also provides a baseline Rete implementation, without these enhancements, against which this work can be benchmarked. The evaluation of the results shows positive improvements over Rete, with no downsides.