• Change the appearance of application (background, fonts, colors)
• search for images
• open the photo gallery
• open google
• start gmail

There was also a nasty deadlock bug still lurking around that only became apparent on the android platform (different threading model from windows, I guess). This should be fixed now. Lots of small improvements have also been added to speed up operations, this is still an ongoing process.

The latest Aici app can now report the battery state, voltage and temperature. Internally, it’s memory usage also been improved considerably, resulting in much better performance, except for the first input statement, which is still dead slow (fixes are under way).

The next release will most likely have something to do with customising part of the look of the application (you know, backgrounds, fonts, colours,..

Get the latest version from the download section.

• manage the android device from within the application
• updated asset editor
• a new chat-log history view (view/tool windows/chatlog history)
• some internal fixes
• improved voice input (new setting available for this in the ‘chatbot properties’ window)
• thesaurus search has been improved.
• thesaurus import has been improved
• thesaurus paths (in input patterns) have an extra pos filter type: ‘any’, for allowing any part of speech.
• thesaurus paths (in input and output patterns) have an extra optional part for selecting the relationship type (ex: ^w->pertainym:any.something)
• Rule layout has been changed: the ‘Response for’ field has been moved from the ‘output’ items to the root of the rule
• the ‘questions-answers’ demo has been updated.
• InvalidRespones: the list can now be assigned sequential or random (for selecting an item)
• InvalidResponse: a single invalid response can now determine if the bot needs to continue waiting for a valid response or not.
• thesaurus variables in input patterns
• the layout of topic editors has been updated (use the first toolbar button to toggle between editing modes)
• generic data import has been added which uses topics to declare how data needs to be imported.
• changed the labeling from ‘bot says’ to ‘output’ and ‘you say’ to ‘input’ to better reflect all the usage cases and not just for defining chat statements.

And for the websites:

• websites can now be installed to any server you like (path can be defined) (servers must support .net 4, MVC3)
• the css file is properly used in the websites (which allows customization)

Known issues still remaining
• contact info needs to be partially imported at the moment, hoping to change this in the future.
• the contact info sync screen closes extremely slow when the process is done (most likely due to garbage collection).
• the first input is processed much slower then the rest. This is due to disk access latencies.
• Accessing the disk is generally very slow so better caching needs to be added.
• The contact info search algorithms are very limited at the moment, this will be fixed

Statics

A static is a regular word, number or sign that has to be matched with the input, depending on the chatbot’s properties, this has to be an exact match or a synonym Spaces and capitals in the input patterns have no importance: spaces (also newlines and tabs) are skipped and capitals are removed. ex:

This is a test.
Some static text.
I am Jan.

Statics have the highest precedence value, so if there are 2 rules that can both match the same input, but the first rule is using all statics and the second isn’t, than the ‘all-statics’ comes first.

Variables

A variable is a named, temporary memory location that will store the input found at the same position as the variable was declared in the pattern. Variables can come in 3 flavors: with a specific length, a range or no length specification.  All can be ‘space collectors’ or not.

Variables with length

The first case is the simplest, this type of variable will only collect the specified amount of input tokens. As an example, take:

Is $name:1 your name?

Is $name:2 your name?

The first example will collect  only 1 word in the variable called ‘name’. So an input ‘Is Aici your name?’ will match, but ‘Is Marie Antoinette your name’ will not.  I’ve added the second example to show what happens with spaces: by default, they are skipped and not counted. So ‘Is Marie Antoinette your name’ will match with the second pattern.

Any type of input part can follow this type of variable, including other variables. This is because the number of words that the variable should collect is always fixed and doesn’t depend on what comes after the variable.

Variables with a range

The second class of variables defines a range. The range determines the minimum and maximum number of words that the variable should collect.  It will stop collecting input before the maximum is reached, when a token is found in the input that is a known next-value of the variable. For this reason, no other variable can come after a ranged-var. That’s because variables can collect any kind of token, so it would be impossible to know where the first variable stops and the second begins. Ex:

Is $name:1-2 your name?

This example will match both ‘Is Aici your name?’ and ‘Is Marie Antoinette your name’.

Regular variables

This type of variable will continue to collect tokens until a known follower of the variable or the end of the input is encountered. As with ranged variables, no other variable can follow this type. Ex:

Is $name your name?

This will match any input of the form ‘Is x your name?’ where x can be of any length.

Space collectors

As already mentioned, variables normally don’t collect spaces. This is primarily to make certain that double spaces are eliminated in compound words. Sometimes however, it is required to store the spaces. For instance, in file paths, spaces tend to play an important role. That’s why all 3 types of variables can be expended with ‘:CollectSpaces’ (capitals not important). This will let the pattern matcher know that it needs to collect the spaces in between the words. They wont be counted in the length or range though. Ex:

Copy $from:3:collectspaces to $to
Copy $from:3-3:collectspaces to $to
Copy $from:collectspaces to $to

The first pattern will collect 3 words with all the spaces in between, the second between 3 and  6 words, all spaces in between and the last will collect any number of tokens.

Thesaurus variables

A thesaurus variable is a named memory locations that stores the input which was found and which is a child of the thesaurus node specified in the thesaurus variable. The thesaurus node is identified through a path. By default, a path is always followed using the ‘is a’ relationship, but this can be overwritten as the first path item after the name of the variable.  Next in the path is always the part of speech value. This can be: noun, verb, adverb (adv), adjective (adj), pronoun (pron), article (art), compelementizer (comp), conjunction (conj), , interjection (inter), preposition (prep), number, integer (int), double and any. The last one is a catch-all that covers all types of pos values. And after the pos, you can optionally declare a series of thesaurus entries that further specify the path. This doesn’t have to start at the root of the thesaurus, as long as enough values are specified to find a single and unique item.

The EBNF for thesaurus variables is defined as:

ThesVariable = ‘^’identifier ['->' relationship ] ‘:’ pos-type { PathItem };
PathItem = ‘.’ ( identifier | ‘(‘ identifier ‘)’ );

Note that path items can be put between brackets. This is for thesaurus entries that consist out of multiple words. This is required cause otherwise the parser thinks that the thesaurus path has come to an end and it will see the next word as a static, which we can avoid by using brackets.

some examples

^input:noun.name

^input:adjective.(age related)

^input->similar:adj.absolute

Thesaurus variables have a bigger impotence compared to regular variables, both are less than statics. A thesaurus variable comes in at about half the weight of a static while a regular value weights only 1/100th of a static.

operators

Operators are used to control the flow of the pattern matching process in some way.

Some examples:

a {b | c}  //matches: a | x a | a b| a b c | a b b | a b c b c b |…

a (b | c)  //matches a b | a c | x x x a b

a [b | c]  //matches a | a b | a c

a && b     //matches a b | a xxx b | a x x b |…

|< a b     //matches a b xxx   but not: xxx a b

a b >|     //matches xxx a b   but not: a b xxx

Most combinations of operators and variables are allowed except that regular variables (that don’t have a single length value), can’t be the first item of an option or loop. This includes any conditionals inside an option or loop: they also can’t be followed by a regular or ranged variable. That is because it is impossible to determine this way which path to follow: a regular variable can collect any kind of text. This problem does not exist with thesaurus variables.

Sub topics and rules

It is possible to reference other topics and rules within a pattern. This means that any of the patterns defined in the topic or rule can be found at that location. It is also legal for a pattern to reference it’s own rule or topic, which creates recursion. This is a very powerful feature, but also dangerous. If not used carefully, you can get into loops that don’t exit.

The EBNF for sub topics and rules:

Sub =  ‘~’ TopicName ['.' RuleName]

TopicName = RuleName = identifier | ‘(‘ identifier {identifier}  ‘)’

ex:

~subject                 //references one of the standard topics

~numbers.Add             //references the add rule within the numbers topic

~(hell world)            //a topic who’s name contains multiple words

Because topics and rules are referenced by their name inside the patterns, each topic and every rule within each topic needs to have a unique name. The editor will verify this, but not enforce it. When you use a duplicate name for a topic, the icon will be red, duplicate rule names will produce errors in the log.

In the mean time though, I think I’ll prepare a simple release, which will run pretty slow.

The process

So, once the cell on the retina did it’s work and the electrical impulse is activated, it travels along a nerve to the brain. From there, that single impulse will most likely activate 1 or more other neurons. These in turn will activate yet another part of the brain and so on and so on. Sometimes the activity can return to the same neurons, causing loop backs. Most likely, this activity somehow finally gets less and less until it dies out (although maybe not completely).

The model

Now, from this simple  process, lets try and create a model that roughly mimics it. So lets pick up some points of interest from the previous description:

• the electrical impulse somehow divides itself over multiple path ways.
• some of these paths die out, others grow.
• there are loop backs
• an electrical signal has a direction: it goes from one point to (an)other(s).
• an electrical signal travels along a path (axons)
• paths connect neural cells

The first thing to notice: something must be happening to the signal cause it is changing. Now, here is where I put down a rule: whatever it is that’s causing these changes, it must either be another neural cell or a pathway (axon), nothing else allowed.

And this is when the idea of resonance was born: what if there are 1 ore more neural cells reacting to the very fact that there is an electrical signal travelling along a pathway, because a cell released some sort of chemicals or some sort of interaction between the 2?  Now, suppose that there are various types of neurons, some of which can change or manipulate other parts of the neural network. These cells could be grouped together into a single cluster and react in sequence to the electrical signal, thus giving the ability to manipulate and change the very signal that caused the activity in the first place.

And thus we get to a programmable network.

A second thing to notice is the ‘split’ behaviour. If there are more neural cells than there are nerves coming into the brain, than the only way that those other neural cells can be activated, is if somehow the electrical impulse divides itself. To mimic this, I introduced the concept of  the ‘split’ instruction. This is a neuron that’s able to change the electrical signal itself by duplicating it and it’s current processing state. Each duplicate however, has small, predetermined variations, causing each signal’s path to grow apart.

So, the windows application provides test-cases, which are simply lists of inputs that need to be sent to the bot and for each input, a regular expression to check the response. Inputs can be stored hierarchical, so that child inputs will only be sent if the parent tested ok.

These test-cases are also an easy way to gather some metrics like how long it takes to process a statement and how many threads were used.

Thesaurus

In the chatbot designer, the thesaurus data is used to express abstract knowledge/relationships between words (the plural of a word, conjugations, the opposite, ‘is a’ relationships,…) . The application provides extensive support for managing this type of data. You can add, delete, move around, import and export single nodes, a section or the entire thesaurus, do searches and much more.

To the left is a screenshot of the thesaurus. It is represented in a tree structure, filtered by pos (part of speech) and the recursive relationship (custom relationships can be added). Below the tree view is a details section for the selected node where you can specify non recursive relationships like conjugations, pos relationships and various other types.

Although you are able to start a new thesaurus from scratch, it is much easier to import an already existing version. There are several thesauri available in the downloads section like a full English wordnet (pretty big) and a compact version currently used in the android version.

Assets

Assets are used to express concrete knowledge (as in: I have 2 sisters). Besides importing and exporting this data, the chatbot designer application also provides a custom editor for managing this type of data. This is a grid based editor with a number of fixed columns. The first 2 are the most important: attribute and value, but there are also who, what, where, when, how, why, then and amount.

Data is entered either by typing in the values, by drag-drop or through selection from a drop down list that provides browsing features for different types of data like the thesaurus, other assets and topics,… Date and time values can also be selected this way. The data type of each element can be represented with an icon to provide a quick overview, as shown in the image to the right.

Topics

Conversations are usually scripted in topics which can also be edited using an editor which is a mix of text processing and structured editors.

The editor supports cut, copy paste of text sections, single patterns and multiple items. Inserts are also supported. It has a built-in spell checker and errors in the patterns are also highlighted (with an error description in the tooltips). All patterns are also automatically compiled (with an option to recompile all the patterns in case related parts have changed).

All code sections can be expanded and collapsed to make reading/editing easier. This can be done for each section individually or all together. The editor can also switch between an auto insert or regular view mode. The latter is shown in the image above. In insert mode, every section has an extra empty line at the bottom that allows you to quickly add new records.

Code

All of the pattern matching algorithms and function extensions are stored in the project itself and not in the application. The latter executes them with it’s interpreter. These algorithms are declared using the neural network language, a C#-like programming language. In it’s first incarnation, there was no textual representation for this language, only a graphical editor, which is still used for debugging (and also editing). There is currently no special support for working with the source files apart from an import (compilation) and export (rendering) feature. Editing can be done in any regular text-editor (syntax highlighting definitions have already been made, contact me if you’d like to have one).

More

There are many more ways to manage data:

With project overview, you can manage all the topics, assets and other data elements contained in your project. You can add, delete, move, rename, open, export and import items from the project manager. It also provides a short-cut to easily replace topics with newer versions.

The neural network designer version also contains an explorer that provides a list of all the items defined in the project. It allows you to delete and open all types of neurons in the editor or inspect them using a tree that displays all the related items (outgoing and incoming links, parent and child relationships). And you can always sync the currently selected item from any part in the application, with the explorer.

The neural network designer version provides many more editors that can be used to manipulate various data structures that can be used for visual recognition, audio processing, pattern matching,…

Most of these editors are in constant development. New features and improvements tend to be added as needed. If you have any special requests, you can always post it in the forum section.