The ABLE package provides a set of core beans for data access, data translation and filtering, learning, reasoning, and optimization.
These core beans provide basic capabilities which can be combined to create function-specific agents and application-specific agents. Users can easily provide custom beans for use with the Able framework by subclassing the AbleObject class.
The primary components used in ABLE are called AbleBeans, which are JavaBeans that implement the AbleBean interface. Any AbleBean can be manipulated in the Able Editor to graphically construct composite AbleBeans called AbleAgents. The Able framework allows you to create and manage agents. Agents can be created using the Able Agent Editor or your own development environment.
You can think of an AbleAgent as an encapsulated application program. AbleAgents contain AbleBeans and data, property, and event connections. The Able Agents typically include an input data source called an Import; one or more Filter, Rule, or Network beans; and one or more Export beans to process the output data. External programs can serve as data processors for any Able Agent by defining user functions for use as a sensor or effector.
Data or buffer connections between AbleBeans define the data path within the Agent. AbleBeans may be initialized or uninitialized; uninitialized beans are displayed in the Agent Editor as grey or disabled. All AbleBeans have a data flow state, which is either ON or OFF. When AbleBeans are OFF, no data flows through them. Only one Import bean's data connection can be active at any given time. This means that the processing of AbleBeans proceeds as a breadth-first tree structure. No feedback or recurrent connections are allowed between AbleBean buffers in an AbleAgent.
AbleBeans can have multiple input data flow connections, but only one input connection can be active at a time. In contrast, an AbleBean can pass data through multiple output connections at a time. The AbleAgent is a tree structure, and the active Import bean serves as the root of the tree. Multiple trees can exist in a single AbleAgent. However, only one, with the active Import bean as the root, can process data at a time.
AbleBeans as well as AbleAgents can be configured and used in other AbleAgents. This allows a hierarchical composition of agents creating reusable components and more easily maintained applications.
AbleBeans produce, process or receive data. Data flows through the AbleAgent starting at an active Import bean; passing through any connected and ON AbleBeans; and finally, flowing into any connected ON Export beans.
In addition to data flow or buffer connections, AbleBeans can be connected using AbleEvents. All AbleBeans implement the AbleEventListener interface and can process events either synchronously (on the caller thread) or asynchronously (on a separate thread owned by the AbleBean. Each AbleEvent contains a boolean flag indicating whether it should be processed immediately (synchronously) or placed on a queue and processed later (asynchronously).
AbleBeans can also be connected by AblePropertyConnections. A property connection can be used to propagate state changes from one AbleBean to another. When a source property is changed and a standard Java bean propertyChangeEvent is fired, the new property value is set on the destination property (via the setter() method) of the corresponding AbleBean.
The three mechanisms, data flow, events, and property connections allow much flexibility in composing AbleAgents out of other AbleBeans. All three approaches can be used at the same time.
For more information about specific data beans, refer to:
Import beans
Database Import beans
Filter beans
Export beans
Database Export beans
Rules-based systems use if-then rules to develop applications instead of programs. Fuzzy rule systems are a hybrid of traditional rule systems and fuzzy logic, a mathematical system based on fuzzy set theory. Fuzzy sets allow for partial membership in a set, as opposed to the all or nothing values used in standard (boolean) set theory. The advantage of fuzzy rule systems is that the rules can be stated using more natural fuzzy conditions, and the rule processing is performed much faster than the search processes used in traditional expert systems. The fuzzy rule processing provided in Able is most similar to the forward-chaining methodology in expert systems.
Fuzzy rule systems can be used for many of the same functions as neural networks. The primary difference is that the focus is on knowledge rather than data. In order to use rules, you must be able to state the problem solution as a set of if-then statements. The power of the rule-based paradigm is that almost anyone can write at least some rules toward solving a problem. These rules-of-thumb may come only 50% of the way to a solution or 80% there, but rules can provide an easy way for representing and solving difficult problems.
Using Able, you can combine the pattern recognition and modeling capabilities of neural networks with the logical reasoning of rule-based systems. Data can flow from neural networks to rules or visa versa. You can use each technology as appropriate to solve your application problems. User-defined functions are supported so rules can obtain external data while inferencing and also to take actions via calls to methods in Java objects.
The following inferencing techniques are available in the AbleRuleSet; for more information about the rules package, refer to Able Rule package:
Able supports several neural network models as learning beans. A complete list of supported models and their capabilities is provided below.
A neural network model is defined by:
The Able Agent Editor lets you create a neural network bean by selecting the corresponding icon from the Learning icon palette and specify parameters to define the network architecture through its customizer dialog.
Architecture parameters, such as the number of input units and output units, describe a particular instance of a neural network model. During training, the network weights are typically modified under the control of the learning algorithm for that model.
After training, the network is locked to prevent the weights from changing when data passes through the network.
Each neural network model has different strengths and weaknesses, and is appropriate for particular classes of problems. For more information about learning beans, refer to:
Neural Networks, for general information
Back Propagation
Radial Basis Function Net
Self-Organizing Feature Maps
Temporal Difference Learning
User-defined functions are named objects that map to method calls on Java objects. These methods usually make calls to application programming interfaces (APIs) to either obtain data (sensors) or take actions (effectors). AbleAgents manage User-defined Functions and any contained AbleBeans can invoke those functions. A common scenario is for an AbleAgent to contain either a Boolean or fuzzy rule AbleBean that contains sensors in antecedent clauses and effectors in consequent clauses. User-defined Functions take arbitrary argument lists and return Java Objects to the caller.
You can create agents from the beans provided with Able, and you may add custom beans you develop as well. A simple example of a custom bean is provided.