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.

Note: Deprecated!

It’s time again to do a new release, which was long overdue to tell you the truth. Lots of things have been changed, though mostly in the background, both for the designer and Aici. Here’s a non exhaustive list of the changes:

The designer + core:

Basically, I began the process of improving the feel of the application, to get the prototype taste out of it. It’s not done yet, but things are improving considerably. I am now able to work with the designer for a full day, while keeping memory reasonably under control and with the same speed at the end as at the start. here’s what else got changed:

• Lots of speed improvements (more to go)
• fixed some memory leaks, there are still some more left to plug.
• New instructions: IsClusteredByAny, ChangeChild, ChangeInfo, ChangeParent, Avg (average), Max, Min, StDev
• Added system events OnStarted, OnShutDown, OnSinActivity.
• Added a new system variable: Time (to get the current system time).
• Added back/forward commands to the flow editor.
• Added the ability to manage 1 to 1 thesaurus relationships (from within the thesaurus tool window).
• Added ‘go to unfreeze location’ functionality in the memory profiler.
• Created a custom treeview, currently only used by the thesaurus. There are still a few issues left with the new view, but it fixes some unresolvable issues found in the default (wpf) treeview, so all trees will be replace with this new one in the next releases.
• lots of bug fixes

Aici

Aici has undergone a major upgrade, though mostly in the background, that is to say, to improve already existing functionality or extend it. Here’s what’s new/updated:

• There’s a new stage, just after scanning and before parsing, used to retrieve the different sentences and groupings from the input. This allows the system to process multiple sentences in the input (at the same time). 1 small note: the final stage hasn’t been tested yet, so even though the sentences are recognized, only input with 1 sentence is processed correctly at the moment.
• I’ve changed the semantics processing from a simple transition/translation to a full stage, so the semantic information can be used to do more filtering.
• Yet another new stage has been added to do grammatical analysis (things like figuring out whether an ‘a’ is most likely used as a noun or article.
• The output stage has been adjusted so that the output isn’t directly sent out, but instead stored as neurons that can be used for further analysis while being sent out at a later stage. The analysis itself however isn’t done yet.
• Some new frames have been added, mostly to handle invalid grammar and present/past articles.
• The flow definition has been simplified a bit.
• Lots of bug fixes

Aici-Web

And finally, the newcomer: Aici-web which is a web-based interface of Aici (go figure!). It’s currently implemented in Silverlight (other web technologies should follow). The basic purpose of this website version is 2 folded: as a technology showcase and as a way for me to easily get conversation logs that I can use to improve the network. So go ahead and test the limits, see how fast you can break the thing (shouldn’t be to hard ). You can find it here. (Note: I plan to reset the backing database on a regular basis, to keep the thing fresh and with the latest Aici version.)

Note: Deprecated!

The thunk to .Net is finally working:

So it’s now possible to call static functions that take value types as argument and/or as return type.  In this example, I am calling the standard System.IO.File.Copy function to copy a file on my disk. Exceptions are also supported, as you can see from the first line, when I am trying to copy a non existing file. The output comes from the exception generated by the copy. Note that you can specify the arguments in different ways. In this example, I am using the ‘to’ word. ‘From’ would also be recognized. Both determine the extraction order of the arguments.

At the moment, I have hardcoded this extraction of the function arguments for the ‘copy-verb’ manually. The idea is to change it to something more general that can work for any .net function using some meta data of the function (like which neuron to send to which output, how to recognize the arguments, how many arguments,…). I’m not there yet though. First some finishing touches to the designer, so I can trace some neuron/memory leaks. After that I’ll probably do a new release, so you can play a bit.

Oh, and it’s still way to hot outside

Note: Deprecated!

The new release is finally ready.  The Aici demo took a bit longer than planned. Also, lots of things have been fixed and updated. Here’s a non exhaustive list:

• There’s a complete new lockmanager running in the background. This is much more secure (thread-wise, that is) and a lot faster. It’s still a bit of a diesel though, it takes some time for it to get going, but once running, it should be pretty fast. The slow start is due to the storage mechanism (all xml files currently). This is the major drag on the entire system at the moment, and will be fixed next.
• Wordnet import has been seriously updated, a lot more info is retrieved, and it’s now also possible to import the entire db in one go (although not yet advisable, due to a memory bug in the designer, it still takes a major byte out of the hard disk and it simply takes ridiculously long).
• The thesaurus has been given a make over to allow for editing and filtering. He can now also display / edit non recursive relationships. Drag drop is also supported.
• The frame editor has been updated considerably: drag drop support has been added and frame element filters/restrictions have also been introduced (will probably be extended in the future).
• I changed the function of the ‘contains’ operator a bit. It now only checks the contents of a variable. For clusters/children, there are the new instructions (IsClustesteredBy, LinkExists, ContainsChildren, GetInFiltered,…).
• I have added the ‘not contains’ operator.
• New instructions:
• Arithmetic group (+-/*%): I finally caved on those. My original plan was to see how far I got without using any arithmetic in the neural code. I guess, this is as far as I got with that.
• Get-at group: get child at, get cluster at, get out at, get in at, get info at.
• Distinct
• get Incoming, get outgoing, get info, Get in filtered, get out filtered, Get info filtered
• Is clustered by, Link exists, Contains children
• Remove-at group: Remove child at, remove info at, remove link in at, remove link out at
• many, many bug fixes, updates and little improvements.

Aici 1

This demo is a small chat interface. Though, in it’s current state, it’s not much more than a framework. It can initiate a conversation, close it, ask for the name of the user and store the data. It’s not yet able to fully recognize a recurring user since I haven’t defined the neural code for this yet.

I will be explaining how it works and how you can expand on this functionality, shortly. For those who can’t wait and want to get a peek under the hood, here are some pointers to get started:

• There are 3 main stages:
• Flow recognition, which is basically the syntactical stage: check the word types and order. Project pages are:
• the flows (aici/flows),
• the code that is attached to these flows (aici/code/flow code)
• the code that recognizes the flows in the input (aici/code/flow recognition)
• Frame recognition, or the semantics stage. This is where we try to find meaning in the words. Project pages are:
• the frames (aici/frames)
• the code that is attached to the frame sequences (aici/code/frame seq code). The frames don’t have code (yet).
• the code that recognizes the frames in the flow results (aici/code/frame recognition).
• action execution, or the response of the network to the input. Project pages are:
• Actions: all the different actions that the system knows (not yet a lot, should be extended).
• Output: some common code blocks for rendering output. This is also used by the frame sequences, since they are also used to render data in a predefined format.
• Action helpers: code that the action neurons can use to perform common tasks, like stopping a conversation or controlling the timers. Timer callbacks are also stored here.
• The transition between the different stages can be located in aici/code/transition.
• More specifically, the ‘Transition’ neuron is used to go from the flows to the frames and finally to the actions. 
• An action is started using the ‘Execute action’ neuron as meaning for a link from a data cluster to the action that needs to be started.
• The project also contains some mindmaps that describe the inner data structures and functionality.

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.