Technical Summary of AURA Technology

Introduction

AURA comprises a family of generic techniques supporting high-speed search and match operations over a wide range of data types. The system uses a core based on a relatively simple yet extremely powerful binary neural network called Correlation Matrix Memory (CMM) which provides associative memory capabilities. The advantage of using such a simple core is that it permits efficient, high-speed computations from which AURA derives its impressive performance. Augmenting this CMM core, complementary techniques manage the storage and retrieval of a wide range of data-types, translating between external and internal representations. Internal representations are designed to preserve the essential benefits of this novel storage method.

Correlation Matrix Memory

In AURA, the basic functional blocks are binary neural networks (CMM) which support symbolic reasoning, as well as the pattern processing functions associated with neural networks. An important feature provided by this approach is a powerful partial-match mechanism, that supports reasoning with incomplete and uncertain information. Compact implementations using conventional digital hardware have been demonstrated. The high-performance derives from fast CMM computations using simple binary-values, and "one-shot" training where a pattern to be recognised is stored using a few simple binary operations (in contrast with the long training times associated with most other neural networks).

An example of a very simple CMM is shown below. Note that a "real" CMM may have several thousand rows and columns, equivalent to several Megabytes of conventional storage.

Pattern Storage

Complementary techniques in the AURA family are used to pre-process external data into a suitable binary pattern form for storage. In Figure 1(a) above, the input binary pattern (left vertical) is stored in the CMM by "associating" it with another "separator" pattern (left horizontal). The association is formed by making appropriate connections between the row and column "wires" that make up the grid. A simple rule determines that a connection is made between a row "wire" and a column "wire" when a binary '1' appears in the corresponding positions of the two patterns to be associated. Thus if the input binary pattern contains two binary '1' values and the associated "separator" pattern also contains two binary '1' values, then four connections will be added to the CMM. New associations between pattern-pairs are superimposed with existing associations, so that existing connections remain unchanged once created.

Pattern Retrieval

In b) above, the stored association is retrieved by applying only the input binary pattern (right vertical) this time. Wherever a '1' appearing in the input pattern coincides with a connection in the corresponding row of the CMM, a count is incremented for the column connected to that row. The intermediate result is an array of raw output summations (right horizontal). A single, global threshold is applied to the output summation values to obtain the binary "separator" pattern originally associated with the input pattern. There are several techniques for choosing a suitable threshold value, but a typical method is to simply count the number of '1' values used in the input pattern and use this as the threshold. In the example above the number of '1' values is 2 and this is the threshold value used.

Finally, when the thresholded binary "separator" pattern is obtained, other techniques in the AURA family are used to recover individual patterns translating these into a suitable external representation appropriate to the user.

Rule-Matching

The following is a brief description of the rule-matching in AURA. AURA provides facilities enabling high-speed matching for a knowledge base consisting of rules that have the typical form:

{condition-expression} -> {action-expression}

The architecture exploits particular properties of correlation matrix memory (CMM) to support evaluation of such rules, which generally contain bound symbolic references to environment variables. One important property is the robust associative recall of stored patterns, even if the input selector-pattern is degraded due to noise (for example). This provides the basis for a powerful form of partial matching which can be performed with incomplete expressions (i.e. in which some environment variables are not available).

Figure 2: Basic Functional Blocks for Rule-Matching in AURA

The architecture is based on the use of an array of correlation matrix memory (CMM) binary neural networks, supported by mechanisms which:

• convert each lexical token into a binary pattern vector with exactly k bits set
• perform binding of variable-names to values
• form superimposed codings of sets of bound variables
• route the superimposed sets to appropriate CMM networks
• resolve multiple network outputs (which occur in the form of superimposed binary patterns)

The system is first trained with a knowledge base, i.e. a set of rules or predicates. In operation, values become bound to environment variables, forming the input to AURA. Thus rules in the knowledgebase become eligible to be "fired" when the configuration of variables satisfies the pre-conditions of those rules.