A concurrent rule scheduling algorithm for active rules

The use of rules in a distributed environment creates new challenges for the development of active rule execution models. In particular, since a single event can trigger multiple rules that execute over distributed sources of data, it is important to make use of concurrent rule execution whenever possible. This paper presents the details of the integration rule scheduling (IRS) algorithm. Integration rules are active database rules that are used for component integration in a distributed environment. The IRS algorithm identifies rule conflicts for multiple rules triggered by the same event through static, compile-time analysis of the read and write sets of each rule. A unique aspect of the algorithm is that the conflict analysis includes the effects of nested rule execution that occurs as a result of using an execution model with an immediate coupling mode. The algorithm therefore identifies conflicts that may occur as a result of the concurrent execution of different rule triggering sequences. The rules are then formed into a priority graph before execution, defining the order in which rules triggered by the same event should be processed. Rules with the same priority can be executed concurrently. The IRS algorithm guarantees confluence in the final state of the rule execution. The IRS algorithm is applicable for rule scheduling in both distributed and centralized rule execution environments.     

Prolog/Rex inference engine

Abstract: Prolog/Rex supports the construction of knowledge-based systems, allowing frames (Prolog/Rex concepts) and rules to be combined, and providing language level support for hypothetical reasoning and assumption-based truth maintenance (Prolog/Rex viewpoint mechanism). To increase run-time performance during rule execution, Prolog/Rex provides two complementary rule compilation techniques: the simple indexing scheme and the heavily modified Rete expansion method. To improve the efficiency of the inference engine, we built an agenda-based rule manager that uses priority mechanism and/or heuristics embedded in meta-rules to control the rule firing order. Forward- and backward-chaining can be combined within the same program.     

Meta-association rules for mining interesting associations in multiple datasets

Association rules have been widely used in many application areas to extract new and useful information expressed in a comprehensive way for decision makers from raw data. However, raw data may not always be available, it can be distributed in multiple datasets and therefore there resulting number of association rules to be inspected is overwhelming. In the light of these observations, we propose meta-association rules, a new framework for mining association rules over previously discovered rules in multiple databases. Meta-association rules are a new tool that convey new information from the patterns extracted from multiple datasets and give a “summarized” representation about most frequent patterns. We propose and compare two different algorithms based respectively on crisp rules and fuzzy rules, concluding that fuzzy meta-association rules are suitable to incorporate to the meta-mining procedure the obtained quality assessment provided by the rules in the first step of the process, although it consumes more time than the crisp approach. In addition, fuzzy meta-rules give a more manageable set of rules for its posterior analysis and they allow the use of fuzzy items to express additional knowledge about the original databases. The proposed framework is illustrated with real-life data about crime incidents in the city of Chicago. Issues such as the difference with traditional approaches are discussed using synthetic data.     

DESIGN AND IMPLEMENTATION OF A REASONING ENGINE USING GENERALIZED META-RULES TO EXPRESS CONTROL KNOWLEDGE

This article describes the design and implementation of the reasoning engine developed for the interpretation of FLORIAN rule language. A key feature of the language is to allow the specification of control knowledge using generalized meta-rules. The user can define how to solve conflicts at the object level, at the meta-level, or at any higher level using meta-i-rules. Object-level rules and generalized meta-i-rules share the same rule format. Several examples of meta-rules and higher level rules are presented using the rule syntax. The architecture and working of the rule interpreter is analyzed, describing the main algorithms and abstract data types implementing The reasoning engine.     

Delta abstractions: A technique for managing database states in runtime debugging of active database rules

Delta abstractions are introduced as a mechanism for managing database states during the execution of active database rules. Delta abstractions build upon the use of object deltas, capturing changes to individual objects through a system-supported, collapsible type structure. The object delta structure is implemented using object-oriented concepts such as encapsulation and inheritance so that all database objects inherit the ability to transparently create and manage delta values. Delta abstractions provide an additional layer to the database programmer for organizing object deltas according to different language components that induce database changes, such as methods and active rules. As with object deltas, delta abstractions are transparently created and maintained by the active database system. We define different types of delta abstractions as views of object deltas and illustrate how the services of delta abstractions can be used to inspect the state of active rule execution. An active rule analysis and debugging tool has been implemented to demonstrate the use of object deltas and delta abstractions for dynamic analysis of active rules at runtime.     

Issues in the Design and Control of Parallel Rule-Firing Production Systems

The parallel execution of rules in a production system provides the potential for faster execution, but increases the complexity of control and design issues. We address two issues: controlling the execution of productions without introducing serial bottlenecks and maintaining correctness during the course of simultaneous rule executions. Two novel rule-firing policies are described: an asynchronous rule-firing policy that causes rules to be executed as soon as they become enabled and a task-based scheduler that allows multiple independent tasks to run asynchronously with respect to each other while allowing rules to execute either synchronously or asynchronously within the context of each task. Previous research in parallel rule-firing systems has indicated that a serializable result cannot be guaranteed without a run-time mechanism for detecting potentially harmful rule interactions. Our analysis of such mechanisms indicates that their overhead is prohibitive for asynchronous rule-firing systems. In exchange for improved performance, we trade the guarantee of serializability for the somewhat weaker claim that correct parallel rule-firing programs may be designed, given the appropriate language mechanisms. We present a simple locking scheme for working memory, which, when coupled with the appropriate language idioms, allows serializable programs to be developed without incurring the expense of run-time interference detection. The experimental results of this research are presented in the context of UMass Parallel OPS5, a rule-based language that incorporates parallelism at the rule, action, and match levels, and provides language constructs for supporting the design of parallel rule-based programs. Results are presented for a number of programs illustrating common AI paradigms including search, inference, and constraint satisfaction problems.     

Effective scheduling of detached rules in active databases

While triggers have become a classical ingredient of relational database systems, research in active databases is aiming at extending the functionality and expressive power of active rules beyond the scope of relational triggers. One of the most important current trend concerns the support of detached active rules, i.e., of rules which are executed as separate transactions, running outside of the scope of the transaction which generates the triggering event. Detached rules have important applications in workflow management and global integrity maintenance across transactions. One of the main issues in designing the rule engine for detached rules is determining their optimal scheduling. In this paper, we study the performance of a detached rule scheduler whose objective is to minimize the interference of detached rule execution with regard to the normal transactional load. This objective is achieved by executing detached rules at given periods of time and by assigning them a fixed amount of dedicated threads; we study the performance of the scheduler relative to the two most critical design parameters, the frequency of execution of the scheduler, and the number of dedicated execution threads.     

Supporting production rules using ECA rules in an object-oriented context

This paper presents an approach to implementing production rules for object-oriented databases (OODBs). The approach builds upon earlier work on production rule algorithms for relational databases, and exploits fundamental differences in the structuring mechanisms employed by OODBs. An implementation is described whereby the production rules are mapped onto eventcondition action rules for execution. It is shown how the resulting implementation has minimal space overheads, and a time performance close to that of the widely used TREAT algorithm which uses significantly more space.     

Modular Structural Operational Semantics with Strategies

Strategies are a powerful mechanism to control rule application in rule-based systems. For instance, different transition relations can be defined and then combined by means of strategies, giving rise to an effective tool to define the semantics of programming languages. We have endowed the Maude MSOS Tool (MMT), an executable environment for modular structural operational semantics, with the possibility of defining strategies over its transition rules, by combining MMT with the Maude strategy language interpreter prototype. The combination was possible due to Maude's reflective capabilities. One possible use of MMT with strategies is to execute Ordered SOS specifications. We show how a particular form of strategy can be defined to represent an OSOS order and therefore execute, for instance, SOS specifications with negative premises. In this context, we also discuss how two known techniques for the representation of negative premises in OSOS become simplified in our setting.     

Automated construction of fuzzy event sets and its application toactive databases

Fuzzy sets and fuzzy logic research aims to bridge the gap between the crisp world of maths and the real world. Fuzzy set theory was applied to many different areas, from control to databases. Sometimes the number of events in an event-driven system may become very high and unmanageable. Therefore, it is very useful to organize the events into fuzzy event sets also introducing the benefits of fuzzy set theory. All the events that have occurred in a system can be stored in event histories which contain precious hidden information. We propose a method for automated construction of fuzzy event sets out of event histories via data mining techniques. The useful information hidden in the event history is extracted into a matrix called sequential proximity matrix. This matrix shows the proximities of events and it is used for fuzzy rule execution via similarity based event detection and construction of fuzzy event sets. Our application platform is active databases. We describe how fuzzy event sets can be exploited for similarity based event detection and fuzzy rule execution in active database systems     

Graph-based rules and transactions for parallel and active database systems

Active database management systems are becoming increasingly popular because of their relevance to several advanced and complex database applications. The need for user-defined execution orders (or control structures) for rules is well recognized by researchers of active database management systems. Priority-based approaches (e.g., numeric priorities) have been used to specify a desired control structure among rules. However, due to the fact that fixed priorities are assigned to rules, independent of different contexts in which they may be triggered, the existing approaches are not able to allow rules to be executed following different control structures when they are triggered by different events. More flexible and expressive control mechanisms are often needed for rules in advanced database applications such as CAD/CAM, CASE, CIM and flexible manufacturing systems. Since rules in database environments are executed in a transaction framework, an expressive transaction model is needed to model complex control structures among rulesuniformly. In this work, we separate the event part from the condition-action parts of a rule and associate it with a rule graph which represents a set of rules (actually a set of condition-action pairs) sharing the same control structure. Different rule graphs can be defined under different event specifications thereby enabling a set of rules to follow different control structures when triggered by different events. We also use an expressive graph-based transaction model to incorporate the control structures of rule graphs uniformly in a transaction framework. The proposed rule and transaction modeling and execution techniques have been implemented and verified on a shared-nothing multiprocessor computer nCUBE2. In this paper, we also describe the client-server architecture and different parallel transaction and rule execution techniques that have been used for the implementation. Finally, we analyze the speedup and scaleup of the implemented system.     

基于条件冲突分析的主动规则集汇流性判定方法

主动规则使数据库具备自反应能力,在数据库、知识库和无线传感器网络等领域得到了广泛应用。汇流性分析是保持数据一致性的重要手段,但有效判定汇流性仍是一个难题。现有的方法基于规则可交换性进行判定,没有考虑规则之间是否存在条件冲突而导致它们不可能同时出现在同一个执行序列中;同时基于触发关系的集合分析没有考虑在规则触发序列中的先后时序性。为此,提出了规则的触发序列概念,分析了单个触发序列上的条件冲突和一对无序规则所在的两条触发序列之间的条件冲突,从而提出了更有效的汇流性先决条件及其判定定理,同时给出了新的判定算法的完整描述及其可终止性、正确性证明和复杂度分析。     

PEARD: A Prototype Environment for Active Rule Debugging

This research has investigated dynamic, execution-based rule analysis through the development of a Prototype Environment for Active Rule Debugging, called PEARD. PEARD simulates the execution of active database rules, supporting the Event-Condition-Action rule paradigm. Rule definition is flexible, where changes to rules can be applied immediately during a debugging session without recompiling the system. A breakpoint debugging tool allows breakpoints to be set so that the state of variables may be inspected and changed anytime a breakpoint is reached during rule execution. A rule visualization tool displays the rule triggering process in graph form, supporting different visualization granularities to help the user to understand rule execution. Color coding is also used as part of the visualization tool to help the user see where the different parts of an ECA rule are executed due to deferred coupling modes. Users can examine different parts of the rule graph display to inspect the state of a transaction at different rule execution points. Other debugging features include a means for detecting potential cycles in rule execution and a utility to examine different rule execution paths from the same point in the rule triggering process. Our experience with PEARD has helped to identify some of the useful functional components of an active rule debugging tool and to identify research directions for future active rule development environments.This research was partially supported by NSF Grant No. IRI-9410993.     

Simple control rules in a cooperative system for dynamic optimisation problems

The use of centralised, multi-threads cooperative systems, has emerged as a successful alternative to deal with static optimisation problems, avoiding the problem of selecting a particular, isolated strategy. However, when the problem to deal with becomes dynamic in some sense, the question as to whether those systems and the type of control rules employed to control the threads are useful or not remains open.

In this article, we depart from a strategy that joint uses a set of solutions and a set of simple agents, and we propose, compare and test two control rules for updating the former. The rules are a simple replacement frequency mechanism and a fuzzy set based one.

Computational experiments are performed on the moving peaks benchmark problem under different scenarios and the main conclusions are: first, the fuzzy set based rule is better than the frequency based rule and second, both rules are competitive when compared with a state-of-the-art algorithm.     

Scalable Parallel and Distributed Expert Database Systems with Predictive Load Balancing

Much prior work in AI on various attempts to speed up rule-based systems by parallel processing has been reported. Unfortunately, many of these results indicate that there is limited parallelism to be found when rules are applied to relatively small amounts of data. Thus, one can predict that much greater parallelism can be extracted when rules are applied to large amounts of data. However, traditional compile-time parallelization strategies as developed for main-memory based systems do not scale to large databases. We propose a scalable strategy for the efficient parallel implementation of rule-based systems operating upon large databases. We concentrate on load balancing techniques in a synchronous model of rule execution, where the variance in runtime of the distributed sites is minimized per cycle of rule processing, thus increasing utilization and speedup. We demonstrate that static load balancing techniques are insufficient, and thus low overhead dynamic load balancing is the key to successful scaling. We present a form of dynamic load balancing that is based upon predicting future system loads, rather than conventional demand-driven approaches that monitor current system state. We analyze a number of possible predictive dynamic load balancing protocols by isoefficiency analysis to guide the design of a parallel database rule processing system.     

RSF: a formalism for executable requirement specifications

RSF is a formalism for specifying and prototyping systems with time constraints. Specifications are given via a set of transition rules. The application of a transition rule is dependent upon certain events. The occurrence times of the events and the data associated with them must satisfy given properties. As a consequence of the application of a rule, some events are generated and others are scheduled to occur in the future, after given intervals of time. Specifications can be queried, and the computation of answers to queries provides a generalized form of rapid prototyping. Executability is obtained by mapping the RSF rules into logic programming. The rationale, a definition of the formalism, the execution techniques which support the general notion of rapid prototyping and a few examples of its use are presented     

ETARM: an efficient top-k association rule mining algorithm

Mining association rules plays an important role in data mining and knowledge discovery since it can reveal strong associations between items in databases. Nevertheless, an important problem with traditional association rule mining methods is that they can generate a huge amount of association rules depending on how parameters are set. However, users are often only interested in finding the strongest rules, and do not want to go through a large amount of rules or wait for these rules to be generated. To address those needs, algorithms have been proposed to mine the top-k association rules in databases, where users can directly set a parameter k to obtain the k most frequent rules. However, a major issue with these techniques is that they remain very costly in terms of execution time and memory. To address this issue, this paper presents a novel algorithm named ETARM (Efficient Top-k Association Rule Miner) to efficiently find the complete set of top-k association rules. The proposed algorithm integrates two novel candidate pruning properties to more effectively reduce the search space. These properties are applied during the candidate selection process to identify items that should not be used to expand a rule based on its confidence, to reduce the number of candidates. An extensive experimental evaluation on six standard benchmark datasets show that the proposed approach outperforms the state-of-the-art TopKRules algorithm both in terms of runtime and memory usage.     

标签Petri网的路径信息在故障诊断中的应用

针对一类由标签Petri网模拟的离散事件系统的故障问题,提出一种利用网结构中路径信息的诊断方法.假设标签Petri网模型的网结构是已知的,隐藏在系统传感器或者执行机构中的故障用不可观测的变迁或者可观测且标记不可分辨的变迁模拟.首先,在故障诊断过程前,提出网结构转化规则转化原始Petri网;随后,在转化后Petri网的子...     

Using KBS verification techniques to demonstrate the existence of rule anomalies in ADBs

As the field of verification and validation for knowledge-based systems (KBSs) has matured, much information, technology, and theory has become available. Though not all of the problems with respect to KBSs have been solved, many have been identified with solutions that can be used in an analogous manner in situations where the application is not necessarily a traditional KBS. As one example, the “active” component in an active database (ADB) consists of rules that execute as a result of database accesses and updates. In this paper, we demonstrate that anomalies found to impact the correctness of a KBS can also exist in ADBs. We first compare the rule structure of a KBS with the rule structures of various ADBs. To show their existence, we convert the rule syntax of the ADBs into a consistent format for analysis and anomaly detection. Once converted, we apply KBS verification techniques to isolate these anomalies. Due to the more increasing use of triggered rules in ADBs, this work illustrates the danger these anomalies can pose and the ever increasing need for ADB verification techniques to exist.     

基于数据世系的网络协同入侵检测系统

目前还没有很好的入侵检测方法可以直接对网络复合攻击进行关联分析并获得较好的超报警规则.针对此问题,提出一种基于数据世系的网络协同入侵检测新方法:采用SYSLOG机制设置日志服务器,通过PERM重写技术获得日志世系数据库;利用where世系定位复合攻击者,why世系重构攻击过程,并获得攻击链的信息和超报警规则.数据世系理论和实验证明新方法是可行和有效的.