Readme for the Agent Building and Learning Environment
Version 2.0 June 30, 2003
Topics are:
Welcome
Release Contents
Requirements
Installation and
Running
Known Problems
and Limitations
Support
Change History
Acknowledgements
The Agent Building and Learning Environment (ABLE) is a Java
framework, component library, and productivity toolkit for
building intelligent agents utilizing machine learning and
reasoning. The ABLE
research project is provided by the IBM T.J. Watson Research Center.
ABLE has been named one of IBM's core technologies for Autonomic
Computing.
The ABLE framework provides a set of Java interfaces and base
classes used to build a library of JavaBeans called AbleBeans.
The library includes AbleBeans for reading and writing text and
database data, for data transformation and scaling, for rule-based
inferencing using Boolean and fuzzy logic, and for machine
learning techniques such as neural networks, Bayesian
classifiers, and decision trees. Developers can extend the
provided AbleBeans or implement their own custom algorithms.
Rulesets created using the ABLE Rule Language can be used by
any of the provided inferencing engines, which range from simple
if-then scripting, to light-weight inferencing, to heavy-weight
AI algorithms using pattern matching and unification. Java
objects can be created and manipulated using Able rules. An
Eclipse plugin provides rule editing and debug capability.
Core beans may be combined to create function-specific
JavaBeans called AbleAgents. Agents are provided for
classification, clustering, prediction, and genetic search.
Developers can implement their own AbleBeans and AbleAgents and
plug them into Able's Agent Editor. Graphical and text inspectors
are provided in the Agent Editor so developers can view bean
inputs, properties, and outputs as machine learning progresses or
as values change in response to methods invoked in the
interactive development environment.
Application-level agents can be constructed from AbleBean and
AbleAgent components using the Able Agent Editor or a commercial
bean builder environment. AbleBeans can be called directly from
applications or run autonomously on their own thread. Events can
be used to pass data or invoke methods, and can be processed in a
synchronous or asynchronous manner.
The distributed AbleBeans and AbleAgents are:
Data beans |
|
AbleImport |
reads data from flat text files |
AbleDBImport |
reads data from SQL databases |
AbleFilter |
filters, transforms, and scales data
using translate template specifications |
AbleExport |
writes data to flat text files |
AbleDBExport |
writes data to SQL databases |
AbleTimeSeriesFilter |
collects periods of data for use in predicting future
values |
|
|
Learning beans |
|
Back Propagation |
implements enhanced back propagation
algorithm used for classification and prediction |
Decision tree |
creates a decision tree for
classification |
Naive Bayes |
learns a probabalistic model for
classification |
Radial Basis Function |
uses radial basis functions to adjust
weights in a single hidden layer neural network for
prediction |
Self-Organizing Map |
clusters data using Gaussian
neighborhood function |
Temporal Difference Learning |
uses reinforcement learning for time
series forecasting; gradient descent is used to adjust
network weights |
k Nearest Neighbors |
classifies patterns according to nearest
neighborhood calculation |
|
|
Rules beans |
Inferencing engines include:
- Backward chaining
- Forward chaining
- Forward chaining with working memory
- Forward chaining with working memory and Rete'-based
pattern matching
- Predicate logic
- Fuzzy logic
- Script
|
|
Agents |
|
Genetic search |
manipulates a population of genetic
objects which may include AbleBeans |
Neural classifier |
uses back propagation to classify data |
Neural clustering |
uses self-organizing maps to segment
data |
Neural prediction |
uses back propagation to build
regression models |
Rule |
contains a ruleset whose ruleblocks are processed
when the agent's corresponding methods are executed. |
Script |
runs rulesets you name when its init, process, and
timer methods are called. |
JavaScript |
runs JavaScripts you name when its init,
process, or timer methods are called. |
RemoteAgent |
agent which can wrapper any AbleBean for remote
access |
|
|
Autotune |
includes an AutotuneAgent, Neural2WayLoadBalanceController,
BasicNeuralAutotuneController, and Fuzzy2WayLoadBalanceController |
|
|
Conversation |
includes an
AblePlatformConversationAgent, and AutoConversationSetup
and DefaultDecisionMaker beans |
Release 2.0 June 30, 2003
ABLE 2.0, a core IBM Autonomic Computing technology, has
enhanced rules function, new Eclipse-based tooling, and major
enhancements to the agent platform, including life cycle
services, security, and persistence. Updated Javadocs and bug
fixes.
- The Able Rule Language (ARL) updates include:
- Added getControlParameter() AbleRuleSet methods.
- Changed syntax on Categorical and Discrete
variables to use standard Java object syntax.
- Removed AbleBeanLib, AbleCalendarLib,
AbleMathLib, AbleStringLib, and AbleUtilLib from
driver and moved selected methods into the ARL.java
built-in class.
- Added a number of new ISO Prolog compatible built-in
predicates for use by the Predicate inference
engine.
- Note that these changes mean that agents
containing results are not reserializable from
release 1.5.0.
- New APIs available in the AbleRuleset to reset
bound variables, specifically for repetitive
calls using backward chaining inferencing.
- Enhancements to the com.ibm.able.platform package include
new life cycle services support, new support for secure
transactions, and database persistance.
- Javadoc has been reviewed and updated, specifically for
the com.ibm.able and com.ibm.able.platform packages.
See the Change History for
previous release content.
Platform: JDK 1.3 or later. You can obtain JDK's built by Sun
at http://java.sun.com/j2se/
and by IBM at http://www.ibm.com/java/jdk/download/index.html.
Follow the installation instructions provided at those sites.
Computer: Any Java2-supported system.
Please read the License
Agreement and agree to the terms and conditions before
installing this software.
ABLE Installation Procedures
- Download executables with the able_2.0.0.zip file or the
able_2.0.0.tar.gz file as appropriate.
- Unzip (or untar) the file(s) to a specified drive. The .../able_2.0.0
directory tree will be created and populated.
- Script files to start the Able Agent Editor are in the .../able_2.0.0/bin
directory.
- To reduce download times, help and documentation is
provided in a separate file, docs, which you must be
downloaded separately. Unzip or untar this into the home
directory into the .../able_2.0.0 directory. This
will create .../able_2.0.0/references.
- The documentation root is .../able_2.0.0/index.html
file. If you have not downloaded the separate
documentation, some links will not be available.
Running the Able Agent Editor
- Change to the .../able_2.0.0_/bin directory.
- Run the runnit script appropriate for your system.
Running the Able Agent Editor with Distributed Agents
- Follow instructions in the Platform
Guide to set up your ableplatform.preferences file
and for more details.
- Change to the .../able_2.0.0_/bin directory.
- Run the startPlatform script appropriate for your
system.
- In a new command interpreter window, change to the .../able_2.0.0/bin
directory.
- Run the runPlatform script appropriate for your
system.
This is an alpha level release and not all function and
documentation is complete. General limitations:
- Serialized agents containing com.ibm.able.rules.AbleRuleSet
will not be reserializable.
- The Eclipse plugin should be considered to be an alpha
state of development.
- Platform objects may not be reserializable at this state.
Ruleset limitations:
- Due to limitations of the antlr-based parser:
- Ruleset identifiers cannot begin with an
underscore (_) character.
- Numeric values cannot begin with a period ('.');
use 0.5 instead of .5.
- The value 0xFF does not parse.
- Calling non-static methods in a static way is not
detected until runtime; ideally "Aclass.aNonStaticMethod()"
would produce a parse error stating "Method
<aNonStaticMethod> in class <Aclass> is not
static."
See the FAQ if you encounter problems
installing or using ABLE. The later questions are designed to
assist you with troubleshooting.
We are interested in any feedback you are willing to provide,
whether it is problems you encounter while using this software or
suggestions for future improvements. Please send comments and
questions to ableinfo@us.ibm.com,
post them in the Able discussion forum at http://www.alphaworks.ibm.com/tech/able,
or the newsgroup news://forums.ibm.com/forums.software.able.
Internal IBM users may post or subscribe to the software.able
forum at http://w3.ibm.com/forums/forumlookup/forums.software.able.
Able
release |
Posted at
alphaWorks |
Build
timestamp |
Content highlights |
1.0a |
05/04/2000 |
04/28/2000 |
Initial release to alphaWorks. |
1.1b |
09/28/2000 |
09/28/2000 |
New NaiveBayes, RadialBasisFunctionNet and
TemporalDifferenceLearning beans. Neural network auto-training.
Java2 required. |
1.2a |
12/07/2000 |
12/06/2000 |
Inference engines redesigned; support for user
libraries and Java object scripting, new DecisionTree
bean. |
1.3a |
10/24/2001 |
10/17/2001 |
ABLE Rule Language includes new rule types, new
inference engines (Rete', Prolog), temporal reasoning,
and a rule debugging framework; new Script and JavaScript
agents and a database Import bean; tracing and logging
support. |
1.3b |
01/22/2002 |
01/11/2002 |
Consistent rule validation in all inferencing
methods, String function library added for rule writers,
transaction event support. |
1.3c |
03/29/2002 |
3/27/2002 |
Able Rule Language modified to be more Java-like. Old
form converted automatically and supported in this
release. |
1.4.0 |
10/14/2002 |
10/16/2002 |
Major enhancements to Able Rule Language and
AbleRuleSet bean. New features include FIPA-compliant
distributed agent platform, conversational agents,
Autotune feedback control agents, and Eclipse rule editor
plugin. |
1.5.0 |
3/15/2003 |
3/17/2003 |
Enhancements to Able Rule Language, AbleRuleSet bean
and agent platform. Includes new rule template support,
DBExport bean, RuleAgent bean, and pluggable rule
engines, performance tuning, updated docs, bug fixes. |
Enhancements to Able Rule Language, AbleRuleSet bean and agent
platform. Includes new rule template support, DBExport bean,
RuleAgent bean, and pluggable rule engines, performance tuning,
updated docs, bug fixes.
- The Able Rule Language (ARL) has undergone
some syntax changes, libraries have been eliminated where
methods can now be called directly, and built-in user-defined
functions have been minimized to improve performance. New
functions include templates, pluggable inference engines,
rule priorities now support variables, and new agent AbleRuleAgent.
- Tracing in the AbleRuleSet was found to be impacting
performance so a new method of gating trace statements
was designed and applied.
- Performance improvements and bug fixes in the
PatternMatchRete inferencing engine completed.
- Redesigned which beans are remoteable, adding a new
AbleRemoteAgent and additional remote interfaces.
- Improved formatting of ruleset parsing exceptions.
- AbleDefaultAgent moved from com.ibm.able.agents package
to com.ibm.able. This unfortunately breaks most
serialized agents.
- The rules package is moved from com.ibm.able.beans.rules
to com.ibm.able.rules.
- Messages used for tracing while a ruleset is inferencing
moved externally to a message bundle.
- The AbleBean interface included more methods than were
understandable. Intermediate interfaces have been
provided for AbleDataBufferManager,
AbleEventListenerManager, AbleEventQueueManager,
AblePropertyChangeManager, and AbleSerializable. AbleBean
extends each of these intermediate interfaces which were
added largely for documentation.
- Packaging has been revised to
eliminate redundancy between jars, including eliminating
the ableall.jar, placing the rules package in its own
jar, and creating a new ablex.jar for experimental,
prototype, or deprecated beans. The ablejas.jar is
renamed ableplatform.jar. A major goal was to reduce the
size and number of able jars required to deploy agents.
- Reduced reliance on JAS reference implementation,
reflected in renaming of many components that included
the acronym JAS to Platform. The command files run/startjas
are now run/startplatform. Preferences stored in ablejas.preferences
are renamed and significantly changed in ableplatform.preferences.
See Platform
Guide and example ableplatform.preferences.
- Tips section added to documentation for the ARL editor
plugin to the Eclipse tool com.ibm.able.ui
includes tips for setting able.home in eclipse and for
developing Java classes in conjunction with rulesets.
- New bean for writing to SQL database AbleDBExport,
and a new interface AbleDataSink for beans which write
data.
- Fixes to the Inspector scatterplot view.
- Xerces version 3.2.3 has replaced the former 3.0.1 in the
shipped xerces.jar.
Major enhancements to Able Rule Language and AbleRuleSet bean.
New features include FIPA-compliant distributed agent platform,
conversational agents, Autotune feedback control agents, and
Eclipse rule editor plugin.
- The Able Rule Language (ARL) evolution to
Java is complete. Examples
of the new syntax are provided with a comparison to the 1.3b
version.
1. Java-like syntax -- ARL subset uses equivalent Java
syntax, with ARL-specific additions.
2. Arbitrary nesting of AND/OR/NOT expressions.
3. Function nesting (e.g. Math.sin ( Math.tan (1.4) )).
4. Arbitrary math expressions x = x + 1; and y = ( z * 4
) / k.
5. Data Types - add TimeStamp, TimePeriod, Integer,
Double, Float.
6. Inference method names (Forward2 is now PatternMatch,
Forward3 is now PatternMatchRete).
7. Add return parameter from ruleblock ... use
returnFromRuleBlock() built-in function.
8. Define simple inner classes in ARL: use JikesBT, front-end
completed.
9. RuleBlock supports inference method on each rule block.
10. Dot notation on method invocation on object variables.
11. Inference engine controls set using built-in function
setControlParameter; are variables rather than constants.
12. Added match() function to do queries against WM (need
Selector data type); use find() findAll() in wm.
13. Added named patterns (Expressions) and Selector (added
as built-in type).
14. Exception rule block handles exceptions from
AbleRuleSet process().
15. Added enabled/disabled flag to rules to allow rules
to be turned on/off as necessary (like by date/time).
16. Added start/stop Date/Time stamps to each rule (implemented
IETF TimePeriods).
17. Added array support for built-in and user-defined
data types, including array initializer support in
ruleblock.
18. Remove AbleListVariable and AbleListLib - use java.util.Vector
instead.
19. Slash '/' as legal char in identifiers ... changed
functions{ } to look for (ident '/' int ), remove '/'
from identifier list.
20. Built-in data types are implicit imports rather than
keywords (treated similar to imported types).
21. Allow variable definition with null value such as
MyType var1 = null ; or MyType var1 ;
22. Added comment field to AbleRuleSet, AbleRuleBlock,
Rules, and Variable using JavaDoc style.
23. Implemented do/while , and add for-loop rule.
24. Added ARL.constants to com.ibm.able.beans.rules.ARL
class.
25. Added support for bitwise operators &, |, ^, ~
and modulo %.
- A new package, com.ibm.able.jas,
provides a distributed agent platform compliant with JSR87.
- A new package, com.ibm.able.conversation,
provides conversational beans, agents, and examples.
- A new package, com.ibm.able.autotune,
provides agents, beans, and metrics for generic adaptive
control applications.
- A plugin to the Eclipse tool, com.ibm.able.ui,
is provided for editing Able RuleSets within the Eclipse
and Websphere Studio Workbench development environments.
- New beans and agents for classification are included
using a k-nearest
neighbors algorithm, and alternate algorithms for decision
trees and naive
Bayes.
Able Rule Language modified to be more Java-like. Old form
converted automatically and supported in this release.
- The Able Rule Language (ARL) has been significantly
modified to make it more Java-like. Rulesets are now
written to files with an extension of .arl rather than .rs.
The Ruleset Editor includes a conversion utility to
convert the old form to the new.
- A new method added to AbleWorkingMemoryLib, assertDataSource,
allows elements in a text file or database to be
converted into objects and added to working memory.
- A new rule library, AbleUtilLib,
provides limited access to objects and methods in the
java.util package. Note that the next release will allow
methods to be called directly on Java objects without
such wrappers; hence limited function has been added.
- New boolean logic methods bAnd, bOr,
bXor, and bNot added to
the AbleMathLib.
- The following changes were made to the Rule Editor:
- After an old ARL ruleset is parsed, the ruleset
may be converted to the new ARL format. The
option is under the Edit dropdown menu.
- Additional templates added for while and do/until
rules.
- The following documentation changes were made:
- Documentation for the new ARL syntax is only
partially complete.
- Significant fixes include:
- Fixes to the AbleGeneticAgent related to the
conversion from separate sensor and effector
classes to the AbleUserDefinedFunction design.
- AbleWorkingMemoryLib serialUID field added.
- Updated to JLog 2.2.
Consistent rule validation in all inferencing methods, String
function library added for rule writers, transaction event
support, inspector and exception enhancements, and fixes for
predicate inferencing.
- Each inferencing method now consistently validates rules
and reports errors during parsing.
- A new function library, AbleStringLib,
provides string operations for rule writers.
- The AbleBeanLib function library now
includes methods to invoke platform-specific and generic
commands.
- New fields in AbleEvent for replyTo, replyWith, and
transactionID. Support for send/respond transaction
events.
- New field in AbleException allows an exception to retain
a reference to a bean, or contain a list of exceptions
when processing a collection of beans. This enables an
agent to identify failing beans and take action to
recover.
- The following changes were made to the Agent Editor:
- Custom inspector views are preserved when an
agent is serialized.
- Inspector Data menu appropriately displays the
data type inspected when an agent is reserialized.
- The connection view is preserved in user
preferences.
- An 'all' connections view is available.
- The following documentation changes were made:
- A new chart
illustrates the degree of support that each
inferencing engine provides for specific Able
Rule Language features.
- JavaDoc for the AbleScriptAgent and
AbleJavaScriptAgent.
- Significant fixes include:
- Fixes for predicate inferencing to the rulesets
themselves to import the AblePredicateLib and to
the inferencing engine itself to prevent a null
pointer error.
- Fix to the AbleNeuralClassifierAgent - test
import did not contain data fields.
- Fixes for the AbleJavaScriptAgent.
- Dangling reference to an AbleDataSource in
AbleDefaultAgent caused AbleDataImports to be
serialized even though deleted.
- AbleObject.notifyAbleEventListeners continues to
notify listeners of events even if one listener
throws an exception; all exceptions logged,
collected and rethrown.
This release includes major enhancements to the ABLE Rule
Language including new rule types, new inference engines (Rete',
Prolog), temporal reasoning, and a rule debugging framework; new
Script and JavaScript agents and a database Import bean; tracing
and logging support; AbleEditor and Inspector enhancements.
- The com.ibm.able.beans.rules package has undergone
extensive changes:
- The binary and fuzzy rules objects and editors
have been merged into a RuleSet object and a
RuleSet Editor.
- New inferencing methods provided for forward
chaining with working memory; forward chaining
with working memory and Rete'-based pattern
matching; script; JavaScript; and predicate logic.
- The period, or dot, character (.) is no longer a
valid character in IDs. For example, if you have
a variable named var.Test.1, you must change the
name so that there are no dots in the name.
- Variables may be declared as "static".
Static variables are not reset on each process
call to the ruleset.
- There is a new variable type List, for
maintaining lists of objects.
- There is a new variable type, called User-defined
type, that allows you to define variables of
any type. This is accomplished in two steps:
- Use the new Types statement to
assign a type to a Java class. For
example, Types(hammer: "com.binford.tool.Hammer").
This equates the hammer variable
type with the Java class com.binford.tool.Hammer.
- Define variables of the new type. For
example, myHammer hammer("Claw").
Note that you can pass arguments to the
constructor of a user-defined variable,
as shown here.
- You can access fields within a typed variable by
using a new dot notation. For example, if the
hammer class contains the fields "length"
and "weight", you can access those
fields by writing myHammer.length and myHammer.weight.
- The following variables are built-in:
- this Refers to the
ruleset itself.
- parent Refers to the
object that contains the ruleset.
- functionList Refers to
the set of imported functions.
- variableList Refers to
the set of global variables.
- inputBuffer Refers to
the ruleset's input buffer.
- outputBuffer Refers to
the ruleset's output buffer.
- wm Refers to the
ruleset's working memory, if any.
- null A null value.
- The Import statement now requires double
quotes (") around the package name. For
example, Import("com.binford.tool.ToolLib").
- The following libraries are considered built-in,
and do not need to be explicitly imported:
AbleBeanLib, AbleListLib, and AbleMathLib.
Libraries that must be imported are:
AbleCalendarLib, AbleDebugLib, AbleGUILib,
AblePredicateLib, and AbleWorkingMemoryLib.
- The following ruleset functions are available as
built-in methods: getRuleSetName(), getVariable(),
getNumInputVars(), getNumOutputVars(),
getOutputVars(), setInferencingTraceActive(),
isInferencingTraceActive(), trace(), and most
importantly, invokeRuleBlock().
- The Sensors and Effectors
statements have been replaced with a single UserDefinedFunctions
statement since there is really no need to
distinguish between what was arbitrarily
considered to be a sensor or an effector.
- Multiple, named, rule blocks are allowed within a
single ruleset. The previous, unnamed, rule block
is considered to be the "Main" rule
block. Two other rule blocks have reserved names:
"Init" and "Idle". The init
rule block, if present, is processed once, and
only once. The idle rule block, if present, is
processed each time the main, or unnamed, rule
block quiesces. There may be other rule blocks
with arbitrary names. These are never processed
unless explicitly called from a rule that uses
the new invokeRuleBlock() built-in function.
- Assertions are now processed after input
variables are set. To obtain the previous
behavior, place all assertions in a rule block
labelled "Init".
- There is an additional rule syntax: When-Do, that
is used with new forward chaining inferencing
algorithms.
- And more additional rule syntax: predicate logic
rules, used with a new predicate logic
inferencing algorithm.
- Additional rule options statements Predicates
and GoalPredicates.
- The "=" operator is no longer valid
in comparison clauses. Existing rulesets must
be updated to use "==" instead.
Assignment clauses continue to use "="
as before.
- A debug console is provided to display progress
and step through statements in a ruleset.
- Error messages are more meaningful.
- Additional rulebases and sample code are provided
in the examples/rules
directory.
- New beans include:
- A Database Import bean to obtain data from SQL
databases.
- A Time Series Filter bean, provided to collect a
set of input records for the prediction agent's
use in forecasting.
- A Script Agent with rulesets to define its init,
process, and timer actions.
- A JavaScript Agent whose init, process, and timer
actions call user-supplied JavaScripts.
- Changes in the import data design and implementation
include:
- A new abstract class, AbleAbstractImport, allows
data-specific information to be consolidated in
extending beans while sharing Able behaviors such
as randomized presentation of data and record
blocking.
- A new property, computeStatistics, for the text
import and database import beans allows import
beans that reference a subset of a data source to
share the computed statistics and data
dictionaries gathered from another data source.
If an import is initialized with
computeStatistics off, its statistics values are
obtained from the first import bean in its parent
container's processing list.
- The Self-Organizing Map bean, AbleSelfOrganizingMap,
includes properties for labelling cluster patterns.
- Logging and tracing improvements include:
- Addition of a static message logger for logging
translated user-level messages. Message logging
is sent to the console by default but may also be
directed to file. Three levels of severity are
provided with the desired severity stored in
preferences. Error is the default.
- Addition of a static trace logger for logging
programmer-level trace statements for debugging.
Tracing is off by default but three levels of
detail are available.
- Beans may have their own unique trace logger to
trace their individual execution.
- Updated to JLog 2.1.2. Any beans using the
IEventType class needs to change to IRecordType.
- The following changes were made to the Agent Editor:
- Addition of a static message logger for logging
translated user-level messages. Message logging
is sent to the console by default but may also be
directed to file. Three levels of severity are
provided with the desired severity stored in
preferences. Error is the default.
- Loading beans in the Agent Editor has changed
somewhat. There is a preference value,
PlugInJarDirectory, and now a default value is
provided as lib\plugin. Any beans in jar files
located in this directory will be added to the
Agent Editor palette. If a bean is found, but
cannot be loaded because of a classpath
dependancy, the name of the unloadable class will
be logged if the logging level is warning or
informational. You may have to change your
logging level and either restart the editor or
add the jar to the palette from the Tools menu to
view the message. If you develop your own beans,
it is suggested that your logging level be set to
warning or your trace level to low.
- The Agent Editor bean tree includes context menus.
- The Agent Editor Windows menu pulldown now
includes the Rule editor, and the object icon is
included to aid in identifying the window.
- Properties for the Agent Editor are now
maintained in a separate file, ablegui.preferences.
Both preferences files, including the runtime
properties file able.preferences, are written to
the directory where the able package is installed.
Commented examples for both files are located in
the examples directory.
- The following documentation changes were made:
- Additions to the Tutorial now describe the Rule
Editor, and both forward chaining and fuzzy
solutions for the mortgage underwriting example
are included.
- The root documentation index has added links to
the tutorial, examples, rules documentation, and
agent editor. These links have been removed from
what was termed the User Reference which is now
limited to a reference for beans and agents.
- A bibliography of references has been added.
- The Agent Editor help pulldown menu has been
modified to mirror the root documentation index.
- The inspectors chosen for the serialized examples
have been configured for better demonstrations.
- Significant fixes include:
- Changes to the AbleDefaultAgent class to fix a
problem that prevented an agent that extended
AbleDefaultAgent from passing data via buffers
when in run mode, which included the neural
agents.
- Serialized agents distributed as examples now use
a platform and release independant means of
storing file path information. Examples will work
as distributed on AIX.
- All beans have been examined for serialization
issues. Future releases of Able will attempt to
maintain compatibility with previously serialized
files.
- Some reflection-related issues were resolved
which prevented the Agent Editor from functioning
in JDK 1.4.
A major redesign of inference engines adding support for user
libraries and Java object scripting, new CommonRules and
DecisionTree beans, bug fixes and other enhancements.
- The com.ibm.able.beans.rules package has been
extensively enhanced:
- All the functionality of the com.ibm.able.beans.fuzzy
package can now be found in the enhanced rules
package. The fuzzy package is deprecated
and will be removed in the next release.
- All data, clause, and rule representations use
the data model from the com.ibm.able.data
package.
- Boolean and fuzzy rulesets use common rules,
parsers, and a common ruleset editor.
- Multiple inference engines are provided to
operate on rules: backward chaining, forward
chaining, mixed chaining, and fuzzy logic.
- Rulesets can import complete sensor and effector
libraries, without having to individually name
each sensor and effector.
- Two built-in sensor/effector libraries are
available: com.ibm.able.beans.rules.AbleMathLib,
which provides almost all the methods of java.lang.Math
to rule writers, and com.ibm.able.beans.rules.AbleBeanLib,
which allows, from within rules, arbitrary Java
objects to be created, methods invoked, and
members accessed.
- Rule writers can declare and use "object"
variables, which can hold any data type.
- Rule writers can use the built-in variables
"this" and "parent" to pass
to sensors and effectors, or use in other ways.
"this" refers to the current ruleset,
and "parent" is the ruleset's
containing object, if there is one.
- Input- and OutputBuffers are Object[] arrays
instead of String[] arrays.
- A new learning bean, AbleDecisionTree, was added for
classification.
- An AbleBean is provided to wrapper the CommonRules package available
from IBM alphaWorks. CommonRules is a rule-based
development system for eCommerce applications. After
installing CommonRules, follow these instructions to
unzip the AbleCommonRules
bean.
- JDK version 1.3 is recommended. Version 1.2.2 works with
most Able functions but there are problems when using the
new rule development environment.
- The list of Filter Editor operators has been verified,
and those implemented are: absolute value, acosine, add,
asine, atangent, bit-and, bit-complement, bit-or, bit-xor,
ceiling, cosine, discretize, divide, exponent, floor,
log, max and min for one-of-n data, modulo, none, round,
scale, sine, squareroot, square, table, tangent,
threshold, translate, and truncate. Only those operators
appropriate for a datatype display in the combobox. The Math
class is used rather than StrictMath. Other
operators could be implemented on request including
hyperbolic trig functions, normalization, and base 10 log
and exponential.
- Example data definitions and files have been centralized
in the examples\datafiles directory. Examples of
serialized agents are located in appropriately named
subdirectories under examples.
- The Generate button on the AbleImport bean creates a
convert and revert AbleFilterBean. The convert bean is
attached to the import bean with a data connection.
Major changes are:
- JDK 1.1.8 is no longer supported; minimum JDK version is
1.2.2 with 1.3 recommended. Agents serialized with prior
Able releases will not be compatible.
- Rule languages support XML, which requires developers to
add the xerces.jar file to the CLASSPATH setting.
- The Able package is now split into code and documentation
to make downloads faster.
- Learning beans have been expanded with the addition of AbleNaiveBayes,
AbleRadialBasisFunctionNet and AbleTemporalDifferenceLearning,
and a new network graphic inspector.
- Neural agents have autotrain capability, which switches
modes between train and test as well switching data
inputs between import beans.
- A description of how to extend
Able by providing your own beans is added to the user
reference, and is available separately in PDF
format. It refers to a new sample bean AbleFileWatcher
provided for monitoring file changes.
- The Able Data Model has been externalized in a new
package com.ibm.able.data which will allow people to
create new data types for inferencing/filtering/importing/exporting
by extending the newly exposed data types. A description
in PDF
format is available.
- A new definition file format is in use. The previous
version is read and converted to the new format; the old
design did not support multiple target outputs and did
not share well between algorithms. Import beans can now
read data in sequential or random order.
- Miscellaneous Agent Editor enhancements and cleanup such
as displaying bean state in the tree view, better
handling of the icons on the canvas, able to define a
directory from which to read user-provided jars, user-provided
beans can specify their own tab on the editor bean
palette, consistent look and feel throughout.
- Removed examples/neural/* file from ableall.jar and
ableexamples.jar which caused "class not found
errors" with some JDK versions on Windows.
- Workaround provided for JDK bug which prevented help
browser from opening for JDK 1.2+ users.
This is the first release of the ABLE package.
In general, we will use Java syntax wherever possible and
semantically equivalent. The goal is to minimize the distance an
experienced Java programmer has to go to write rules in ARL. The
basic difference between ARL and Java is that Java methods
contain statements while ARL methods contain Rules. Each rule has
an optional name and priority. Rules can be processed
sequentially or out-of-order depending on the inference method
used by the ARL method.
RuleBlock methods only operate on globally defined (ruleset
scoped) variables. There is no notion of block scoped variables.
When/do and Predicate rules support rule-scoped local variables.
When/do does when the type is included before the variable name.
Otherwise the variable in a when/do selector is assumed to be
global. (this removes case-sensitivity from when/do var
declaration) . RuleBlock method signatures define the return data
type (if any) as well as the inference method and parenthetically
associated control parameters. At this time, we will defer the
inplementation of passing input parameters to ruleblock methods.
New syntax is introduced for ARL when/do pattern match rules
and predicate rules. An AbleRuleSet has a set of predefined
variables that can be assigned values using standard Java syntax.
ARL keywords will be case-sensitive.
Construct |
1.3b Syntax |
1.4.0 Java-like Syntax |
Comment |
// or ; |
Same as Java // or /* */ |
Lineend |
none |
Semi-colon ';' like Java; period '.' for predicate |
JavaDoc Comment |
not supported |
Same as Java /** */; comments above the ruleset and
ruleblock names are kept with the parsed objects |
Whitespace |
Space, tab, cr, lf |
Same as Java |
Identifiers / names |
Same as Java? |
Same as Java |
Booleans |
true/false/True/False |
Same as Java; true/false only |
Numbers |
No e-notation |
Same as Java |
List delimiter |
Whitespace, comma , or both |
Same as Java; comma only |
String |
Same as Java? |
Same as Java |
RuleSet definition |
RuleSet name ( ) |
ruleSet name { } |
Import (User's UDF library) |
Import "myPackage.myClass" |
import myPackage.myClass; |
Types (class alias) |
Type(myType: "myPackage.myClass") |
import myPackage.myClass; |
Inference engine processing options |
keyword(value) |
use setControlParameter built-in method |
InputVariables definition
OutputVariables definition |
InputVariables ( a b)
OutputVariables( rc) |
inputs { a, b } ;
outputs { rc } ; |
UserDefinedFunctions |
UserDefinedFunctions(myUDF/1)
Label: result = myUDF(params) |
functions{myUDF/1};
Label: result = myUDF(params); |
RuleBlock definition |
Rules name ( ) |
void process() using Forward { } |
Variable definition |
Name Type( initialValue) |
Type name = initialValue;
Type name = new Type( init params) ; |
Variable case significance |
global variables begin with lowercase
local variables begin with uppercase |
Java-like: global or local variables begin with
either case except local predicate variables which must
begin with uppercase |
Assertion Rules |
Label : X = Y |
Label : X = Y ; Note left hand side assignment not
required for methods now |
If-then Rules
If-then-else Rules
|
Label : if X == Y then Z = 3 |
Label: if (x == y) z = 3;
Label: If (x > y) { z = 3 ; }
Label: If (x < y) { z= 3;} else { q = 5; } // fuzzy
inferencing does not support else |
Fuzzy if-then rules |
Label: If temp is very hot then fanspeed is high |
Label: if (temp is very hot) fanspeed is high; |
When-Do rules |
Label: When () do () |
Label: When ( ) do { } |
Predicate rules |
Label : head() := tail(), tail() |
Label: head() := tail() |
While do rules |
Label: while() do () |
Label: while() { } // do is optional |
Do until rules |
Name: do () until () |
Name: do { } until ( ) ; |
Logical operators |
and, or, not |
and, or, not, &&, ||, !; single & for
predicate |
Comparison clauses |
Lhs condition Rhs |
Same as Java |
Pattern Match selector clauses |
name Type (constraints ) |
Type name ( ) // local variable
name ( ) // global variable |
Fuzzy Hedge delimiter |
blank between multiple hedges |
comma between multiple hedges |
Fuzzy set definition |
blank between x and y value, comma between points |
comma between both values and points |
Data member access |
myType.name |
myType.name |
Try/catch blocks |
not supported |
exception block provided |
Keywords |
Case insensitive |
Case sensitive (lowercase) |
Method invocation |
invoke(myType,aMethod, args ) |
myType.aMethod(args); |
Switch statement |
not supported |
future: same as Java |
For loops |
not supported |
same as Java |
Here is an example showing an external call to convert a
ruleset to the new ARL syntax:
C:\able1_3c\bin>java -classpath C:\able1_3c\lib\ableall.jar;C:\able1_3c\lib\antl
r.jar;C:\able1_3c\lib\JLog.jar com.ibm.able.beans.rules.ConvertRStoARL C:\able1_
3c\examples\rules\Bugs.rs C:\able1_3c\examples\rules\Bugs3.arl
Here is an example showing how a ruleset is converted
internally to the new ARL syntax:
AbleRuleSet rs = new AbleRuleSet("test") ;
rs.instantiateFrom(rsName, null, false);
rs.init(); // parse String
arlString = rs.arlString(); // construct a new style *.arl ruleset file
FileWriter writer = new FileWriter(arlName) ; // write it out to disk
writer.write(arlString) ;
writer.close() ;
There are some constructs in the format which are not handled
by API conversion. Here is a list of changes observed, and any
manual actions taken when the example rulesets were converted to
ARL 1.4.0 format.
- Comments are stripped out during the conversion process.
Comments restored with copy/paste. Comments at the
beginning of a rules file are not supported - they must
occur after the 'ruleset' statement.
- Spacing and formatting will be consistent but different
than original.
- Numeric values will always be represented in decimal
format, though a trailing '.0' is not needed. Strings '.0
', '.0,', '.0;' and '.0)' can be replaced by ' ', ',',
';', and ')' respectively.
- The use of aliases for variable type is no longer
supported, requiring a new design.
Types (Goal : "java.lang.String")
Goal goal = new Goal("bag_large_items")
for example, was converted to:
String goal = new String("bag_large_items");
- Reserved word Class may not be used as a variable.
- Aliases for Java language classes such as String cannot
be used; converted to use real class in variable
definition.
- Fuzzy set members will be displayed in inverted order;
may wish to change for sake of appearance.
- List members are explicitly displayed after conversion in
a form like [1.0|[2.0|[3.0|[4.0|[5.0]]]]]; could be just
[1,2,3,4,5].
- Scientific notation is not yet supported, though the
conversion process may output numeric data in e-notation.
For now this must be converted manually.
- Conversion of fuzzy set definition which now requires
commas between coordinates:
Trapezoid Few = new Trapezoid( 3 5, 10 12);
for example, was converted to:
Trapezoid Few = new Trapezoid( 3, 5, 10, 12);
The Agent Building and Learning Environment (ABLE) includes a
parser for its Able Rule Language which is built using ANTLR, ANother Tool for Language
Recognition, by Terence Parr.