• The spell checker has been cleaned up some. The custom dictionary is now shared across the entire application.
• There was still a bug in the core split functionality that sometimes resulted in incorrect weights for an object when the same object was the result of multiple paths, but with different weights.
• Asset editors now have a child topic-editor by default in the project view.
• Some cleanups in the import/export functionality of the thesaurus and assets.
• a bug in the handling of variables in patterns (which resulted in invalid value refs sometimes) is also fixed.
• a new tutorial that shows how to do questions, answers and redirections.

Get the latest release from the download page.

support for multiple speech engines

The first, and most fundamental change is the fact that the system now supports multiple speech engines.  At the moment, there is an implementation for the managed and unmanaged Microsoft SAPI versions. Others might follow. The major reason for this feature is that the SAPI libraries behave differently on different systems and OS’s. This was most apparent in the fact that some voices aren’t properly supported in the managed version. That’s why the unmanaged version has become the default, since it is the most powerful and most stable (also in terms of timing), but XP for instance doesn’t support SAPI 5.3, so this requires the managed version. To select the engine you want to use, go to the menu item: tools/options, select the ‘Speech’ tab and use the combo box to select one of the engines.  Note: before switching engine, it’s best to turn off audio input/output on all chatbot channels.

Alternate input

Also new in this version is the ability to select between alternative input text for voice recognition. The system wont yet automatically be trained with this information though. You can turn this on/off with a new button on the chatbot-local toolbar, to the right of the Audio-in button. When turned on, and the speech engine can provide alternate text values, a dropdown-box will be displayed just below the text (one for each speech salvo). You can select an alternate text from this box. Note that if there aren’t any alternatives, no dropdown is shown. Also, the managed engine can give different results compared to the non-managed version.

New demos

Finally, there are a few new demos included in the installer. 3 new demos that show different ways to implement why-because (and also show how to do have and like). The previous release also had a demo for why-because, but it still had some issues.

That’s it for now, more things to follow…

For the curious, there are actually a number of fixes/updates all over the place:

• Importing/exporting part of a thesaurus has been fixed.
• There was a problem in the ‘rebuild project’ procedure for the thesaurus which has been fixed.
• A do-statement of the form #x.z = #y  now gets a correct y value.
• There’s a new CmdShell extension for scraping xml and html files (from the internet or disk)

2 new demo projects:

• weather.dpl: uses the scraper extension to get the weather info from the Google weather api.
• Why_because.dpl: shows a way how you can correctly handle why/because statements. In the process, it also shows how to do ‘be’, ‘have’ and ‘like’. 2 more versions of this demo will follow shortly.

So, with no further ado, here’s the basic version and also the pro (the latter will remain active until the end of the year). I will most likely also release a demo of the designer version – which allows full debugging and extending/replacing of the network – in a couple of days, after I’ve cleaned up some more demo projects.
I might also release a 32 and 64 bit specific version in order to support voices that were compiled for a specific platform, other than the one you are running on. The currently released versions will run at 32 or 64 bit, depending on what system you have.

Please, if you experience any ‘hanging’ situations (no reply is coming and in the lower-right corner, the second nr – with tooltip ‘The total nr of still active processors’ -  never goes back to 0), let me know. Different processors can give different results and I don’t have the resources to spend on different hardware setups, so I’m expecting some ‘issues’ in this area. Your help is much appreciated.

a word about the included demos

• Name & age: contains some patterns that demonstrate how to access the ‘name’ and ‘age’ settings which can be supplied in the ‘chatbot properties’ window.
• SysMan: demonstrates how to access external .net functions. It provides access to most of the File, Path and Directory functions.
• Thesaurus operations: shows how to manipulate (add, remove,…) thesaurus data  using do-patterns.
• Asset operations: shows how you can manipulate the memory.
• Complete the sequence: from the previous demo, shows how to perform the ‘complete the list’ trick.
• All: this is the start of a common, reusable library of patterns, most of which don’t even have output, but only manipulate the memory. I’m hoping that this can become the basis of a new approach to pattern matching.

Also, none of the demos includes thesaurus data. this can be imported from this thesaurus file. I’ve done this cause this data is still ‘under heavy construction’. The thesaurus currently contains a little more than 2000 words (not much), but can easily be extended using different import methods.

Thesaurus variables, sub-topics and InvertedWho

Next week, I’ll probably be spending some time putting together the documentation. In the mean time, there are a few tricks which were used in the common library that I’d like to mention.

Firstly, the whole thing is full of statements like:
^subj:noun.name
^subj:adj.possesive
These are ‘thesaurus’ variables. The first word (in this case ‘subj’) is the name of the variable (so you can access the values in the output or do patterns). The other words describe a path into the thesaurus. Any child of this path will give a match.
Thesaurus variables are very powerful, but also more taxing to the system compared to statics (though, usually less than regular variables). When you have lots of patterns that use thesaurus variables, like the common lib, it’s best not to let the system auto resolve synonyms. More on that later.

A second feature:  sub-topics. This packs a serious punch, in all ways you look at it. In short, it’s possible to reference a single rule or an entire group of rules (a topic) from within another input pattern, like this:
~subject (am|'m|is|'s|are|be) ~object
This single pattern can capture anything from: I’m Jan or my name is Jan over My aunt’s name is Rita to The big tree is a little bigger and anything in between. Even more interesting, this technique allows you to do something that I call ‘topic-inheritance’, which basically means you can extend or overwrite the behavior of patterns. I plan to use this technique to build a ‘Watson’ like chatbot on top of this common lib.

Finally, ‘InvertedWho’ simply refers to how the memory is used in the common lib. The basic topics like ‘subject’, ‘object’, ‘location’, ‘time’ and ‘numbers’ don’t generate any output, but store the data in 2 memory streams: the first forms the ‘inverted statement. So ‘I’ becomes ‘you’ and ‘mine’ ‘yours’ (guess for what that’s used). The second stream tries to store the actual meaning (which is a collection of references to other memory addresses or words grouped in an organized and structured way). These things are done in the ‘do patterns’. These are hidden by default in the editor, but can be made visible on each pattern (or shft + ctrl + d to expand/collapse them all at the same time).

There are many, many more details and cool features to talk about. Stay tuned.

I’ve been having a huge smile on my face all day

For the interested, here’s a screenshot of the rule that enables this trick (click to enlarge):

The important bit is the :complete after the variable $ToComp which performs the calculation.

Here’s another screencast that shows what’s happening behind the scenes (basically, it’s a walkthrough of the neural code in the designer):

Looks pretty cool he? So, what happened? Well in short, I took the neural network designer, removed everything complicated from view that remotely had anything to do with ‘neurons’ but kept all the memory functionality, added a character engine and a simple but powerful pattern matcher (implemented in neural code, pretty cool I think,… and simple stuff).

The character in this demo (actually called Tara – and still in development) is designed and named by Ady Di Pierro from Laticis Imagery.  The drawings were made with DAZ3 and assembled in something very similar to verbot’s CCS file.  In fact, all verbot characters should work in this character engine as well, cause I only added features to the file format but didn’t change any existing.    The images were manually assembled for this character cause there is no char-editor yet.  That is scheduled.

Also check out what Roger Davie (aka Freddy, Admin of the AI  dreams forum) did with the forum’s bot:

The images are also rendered with DAZ. He definitely has the visemes already worked out better than in the first demo.

So, how did all of this come to be, you might wonder. Well, I think you can thank Wendell Cowart from the chatterbox challenge for this. He originally contacted me with a request for a new ‘pattern based’ chatbot project. I took this as a nice challenge to demonstrate exactly just how flexible resonating neural networks are. Soon, Patti Roberts of Bildgesmythe also joined in. Together, they basically told me how they would like to have things, which features they were looking for and such. Thus, this little project was able to come into existence at record speed.
Patti and Wendell also helped out a lot with the initial ‘mid development’ testing, which I’m sure you understand is a pretty frustrating job to do, as things are usually not yet behaving the way they are expected to. So many thanks for cracking out those basic ‘issues’.

Anyway, for those who would like to play with it for themselves, a first public beta release will most likely be coming shortly. Just keep in mind that any first release will be a ‘technology preview’ sort of say.

Note: Deprecated!

Finally, it’s time for a new release. Most of the changes are in the backend this time, though there are a few visual changes. So here goes:

What’s new

Designer and core

• The storage system has been updated to a binary, flat file structure, which improves the operation speed considerably in all areas. This essentially makes the core a true database system, which should be fairly easily scaled (see thesaurus demo project), even over multiple hardware systems (eventually).
• I  have finally implemented the namespaces. These are currently maintained in the background, so you don’t need to worry about them. The only change you’ll notice, is an improved browser popup in the frame and flow editors (see image). Basically, the thesaurus, timers and all the project editors (with their entry points) are included and automatically updated.
• The frame editor has been updated a bit cause the previous datagrid didn’t handle the custom namespace selection object. So back to listview for the frame elements (will be updated when the datagrid is fixed).
• I have also added a new restriction type for frame elements: a custom filter, which allows you to do determine the filter result through code.
• Support for modules has also been included, though not yet properly tested, so the imports will definitely not yet work.
• The speed increase brought some more threading issues to light, I hope they are now solved, but one or two things can still pop up here or there.
• Somehow, I managed to show the thesaurus in reversed order (so the view for the hypernyms was showing that of the hyponyms). While fixing that, I also tried to get it to work with an arbitrary number of elements (so you can also browse a huge thesaurus, the search hasn’t yet been updated though).
• The thesaurus can now also be built automatically, based on the content of the database.
• I have added a dialog to remove clusters that have no children, based on the ‘remove orphans’ dialog. This will probably grow out to a general purpose query window, but that’s for the next version.
• New instructions (some were long overdue):
  • Substract: remove 1 or more neurons from a set, contained by a variable or global
  • Select: perform a filter on the content of a variable or global.
  • Remove Links In: removes all the incoming links of a neuron that have a specified meaning.
  • Remove links out: same as ‘Remove Links In’, but for the outgoing links. These 2 instructions allow you to do without an extra loop, which makes it all more thread save and faster.
  • GetAt: retrieves the neuron at a specified index in the content of a variable/global.
• I have changed the parameters of the split instruction a little bit: I have removed the ‘result cluster’ which was originally used to retrieve the results of a split. This worked ok, but could cause problems when multiple users would be performing the exact same algorithm. The solution was to simply use the already existing ‘GetSplitResults’ function, which now also works after the split (and not just when the split is still running). This means that you manually need to clear the split result cache once you are done with it, otherwise the next split will give some bogus results.
• I have also removed the possibility to assign a weight value to a single neuron. Instead you now assign it to the entire processor. This will assign it’s weight to all of it’s result values when it is done. This way, you can change the weight before you know the actual result.
• Attached neurons are working.
• some cosmetical touch-ups here and there.
• Lots of other bug fixes.

AICI

The aici network demo is slowly starting to function. That is, it is beginning to record data into understandable structures. Though it’s still very early, so lots of stuff still goes wrong or hasn’t yet been implemented. Some fun responses guaranteed. Here are the major changes:

• I’ve managed to simplify the flow recognition algorithm (while fixing some tough bugs), so no more synchronization points for the loops. The designer still allows to change this prop at the moment, but this will be removed soon.  Don’t worry about existing values, they are simply skipped, no longer used.
• Some bugs in the frame recognition section have also been solved.
• I have implemented a first version of the noun path resolver algorithm. This is used to understand statements like ‘my brother’s sister’, ‘I’, ‘my favorite car’, ‘sister in law’. This algorithm is also responsible for generating new ‘compound words’, like ‘brother in law’.
• Compound words are recognized again, at different stages. Some compounds can’t be recognized yet (if they have verbs).
• New frames:
  • Be-unknown noun: sentences with an agent, be verb and a possible noun. Example sentences: I am Jan. It is a cat. My name is Jan. I was Jan. It will be a cat. (preconditions: Jan and cat are not yet  in the network). The frame is triggered when it receives a sentence that might contain a noun, and there is an open question that can consume this value.
  • some more, to much to write all down.
• If AICI knows several different synonyms for the same word, it will now mimic your preferred one. So if you just said ‘bye’, it will also say ‘bye’ next time. If you say ‘goodbye’ next, it will switch to this.
• I have introduced the concept of ‘attributes’. These provide an extra step in the semantics stage. For instance, ‘color’ is an attribute. It’s possible values are: blue, red, black, white, green,… Color is a special attribute, since it changes meaning when applied to different types of subjects. For instance, the sentence: ‘I am blue’ usually means: ‘I am a bit down’. So that’s the semantic part: an attribute can inspect to who it is applied and, when needed, can change the attribute, the owner or the value.

The latest release can be downloaded from here, or from the main menu.

Coming up

Next in line will be the editor views (finally). These are currently built using standard WPF controls (listboxes, treeviews,…), which are, well, not performing as desired: they generally can’t handle more than 2-300 items (if you can’t use virtualization) and, more importantly, have a hardcoded recursion limit that causes serious problems, primarily in the code editor. So I need some custom controls to get the speed and reliability up.

Before this though, I will be spending a little more time with AICI. The algorithms are beginning to work the way I want them to, so it’s time to complete the flows, in order to get a larger part of the English language parsed. And off course, I will be adding a bunch of new frames, actions and attributes.

The engine appears to be stabling out, although it is still acting fishy on single core machines, where there are errors I don’t have on my multi core dev system, so I need to move to a different machine to test this out. The designer is also still very much lingering behind the engine when this is processing at full speed, but the UI should remain responsive now.

I have also included an extra demo project called ‘Scanner’. It is able to transform an input stream containing integers, representing characters, into words and numbers (ints and doubles).  This doesn’t seem much, and it isn’t, except that it is doing this using a couple of flows and a general purpose algorithm (processing is still slow, mostly because the UI is trying to catch up).  This was the guts of the older ‘English language definition’ demo, which I have split into 2: the scanner and the language definition, which is no longer able to do any processing (all code removed). It’s an example of a more complex flow.

The scanner demo also has the number scanning problem fixed (numbers longer than 2 came out with multiple results). This appeared to be caused by deleting a couple of neurons to many (in the scanning algorithm).  I had already experienced the dangers of deleting neurons I thought were no longer used, but which were because of the splits. I will probably have to implement some sort of a garbage collection system to clean up unused neurons (but that’s for later).

Anyway, here’s the latest download (best to remove previous installation before installing this one).

Anyway, here are some of the most significant changes:

• Cut/copy paste system: this was still missing.  The backbone is done, the code and flow editors already have a working implementation, the rest should follow.
• Deletion system: I updated the deletion system so as to better reflect common editing practices.  This is again done for the code and flow editors, the rest will be done later.
• undo system: There were still some issues with undoing network operations.  This should be fixed.  The mind-map editor still requires some redoing in this area (and many more by the way).
• Debugger: This is starting to become really useful.  I would not have been able to get the scanner demo working without this. I’ll explain more about this one in a later post cause it definitely needs some explanation.
• Demos updated:
  • I have split the echo demo in 2: a word echo demo and letter echo demo. Both give a very basic implementation of 2 different coding techniques to use in neural networks: a singular operation, and a collector.
  • The English language  def demo is currently able to scan incoming letters and turn them into words and numbers (although there’s still a problem with the numbers).  This scanner algorithm (which really is a general purpose flow interpreter) will be explained later, cause it’s a bit funky (to say the least). You’ll also probably notice that the UI needs some serious speed tuning in order to keep up with the engine.
• Execution engine: this is where the major hacking had to be done, the axe is still glowing red hot, but it’s running, oh yea, it’s running.
• Some new instructions: More will probably follow, but I’m beginning to get a better picture of instruction requirements.  This is starting to stable out.
• lots and lots of small fixes.

The new release can be downloaded from here, or through the usual links in the menu. I’ll probably be spending some more time on posting new entries to explain the debugger and some algorithms. I might also need to start explaining how you actually do you’re own coding in NND. I’d say: stay tuned.

The solution was very simple and pretty elegant: use a different list to store the result of a split. So now a processor has 2 internal lists: the execution stack used to build the code that should be executed next and a list with the split results (unique neurons) and their weights. A couple of new instructions had to be created to control this list.  No biggie: an Add, Remove, Get and Clear.

Anyway, I’m updating all the documentation now.  If I mist something, don’t forget: 2 separate lists. The next post will probably be a Demos explained on the split.