## Able Beans

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 Beans and Bean Connections

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 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:

Backward
  The backward chaining engine evaluates a goal clause first. Rules are evaluated as needed to determine the value of the goal clause. Only rules which are relevant are processed as it passes through the rule base systematically determining the truth value of the clauses it determines are needed.
Forward
  This lightweight inferencing engine processes if-then rules using forward chaining using only specificity for conflict resolution. Each rule is evaluated and if all antecedent conditions are met, it is placed in the conflict set. The specificity heuristic calls for selecting the rule with the most antecedent clauses in the conflict set to be fired. If more than one rule is selected because they have the same number of antecedent clauses, then one is randomly chosen to fire. When the rule is fired, the consequent clause is evaluated, which usually results in an action being taken (an effector call) or a value being assigned to a value. A variable assignment causes only those antecedent clauses and rules that reference the variable to be re-tested. The inference cycle is then repeated until no more rules can fire.
PatternMatch
  This medium weight inferencing engine uses a working memory or object store and also supports when/do pattern match rules. On each cycle, every rule and object is evaluated to determine the conflict set. A rule is selected from the conflict set based on the rule priority and the number of antecedent conditions. This engine produces results identical to the Forward3 engine, but has much less overhead when working with a small number of rules and/or small numbers of objects in working memory.
PatternMatchRete
  This heavy weight inferencing engine uses adds a Rete-like pattern match network to the Forward2 engine. A pattern match network is used to test objects as they are added to the working memory. Partial matches are cached in the pattern match network. This inference engine produces identical results to the PatternMatch engine, but is much more scalable when there are large numbers of rules and/or large numbers of objects in the working memory.
Predicate
  This inferencing engine uses Prolog-style predicate logic and working memory.
Fuzzy Rules
  The fuzzy inferencing engine provides comprehensive fuzzy system capabilities including sequencing and chaining of rules with intermediate consequent variables. Support is provided for user defined functions which allow rules to obtain external data while inferencing (sensors) and also to take actions via method calls (effectors).
Script
  The script engine simply provides a convenient way to create and manipulate Able beans and objects without resorting to programming. The script is processed sequentially from beginning to end.

### Learning Beans

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 type of processing unit
- The connection topology (feed-forward or recurrent)
- The learning algorithm (supervised, unsupervised, or reinforcement)
- The set of parameters and arrays for storing the state information

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

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.

### Custom Beans

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.