There’s a lot more going on here besides the context sensitive interpretation of ‘blue’ (near the end). But I think that’s the most impressive.

Get the latest installation from the download section.

It’s basically a general purpose network host that only supports the text sensory interfaces for input/output. You specify the network that needs to be run at the command prompt. The installation program will do a default setup to work with the AICI demo, but you can change the shortcut to use your own if you want.

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.

• 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.

I also realized that the flow recognition algorithm simply was not yet mature enough to be used in even the most basic situations. Not just because it was not yet able to process the more complex flow structures, but also because I made a basic design error that I did not yet know off: always put the result cluster on the stack (‘from’ part of link) and the item-to-search in the ‘to’ part. Getting this algorithm ready definitely took the most effort, but it was a grate catalyst to improve the debugger and the execution core. Here’s a (non exhaustive) list of new/changed things:

• New instructions: GetClustersFiltered, GetChildrenFiltered, Freeze
• Added ‘Stop all processors’  and ‘kill single processor’  commands
• Added import of VerbNet data
• Updated Frame editor so that it is able to edit VerbNet data, this is a work in progress, not all data items found in verbnet can already be edited.
• major update to the scanner demo
• Added the start of the AICI 1 demo, which will/should soon become able to parse the English grammar (it’s already able to parse the verb ‘to be’ ex: you are, I am, is he, he is, they were,.. (silly I know, but a start is a start!)
• Updated flow editor with overlay items, which display the presence of certain (useful) links, like code that is attached to the flow item.
• Added a new dialog: ‘Overlay editor’ in the Tools menu for editing the overlays that are defined in a project. This means that overlays can eventually be used everywhere.
• new debug feature: split paths, which allow you to track previously recorded paths of processors.
• new debug feature: attached neurons, which allow you to track down data changes in threads that should not be allowed to change the data.
• Extra info about the static neurons (like the display title and the description) is now stored globally, outside of the project so that I only have to update 1 thing, and not all the projects whenever some documentation needs to be updated. This does mean that you can no longer store any description info for these statically defined neurons.
• Updated the WordNet sensory interface so that it generates POSGroup objects, which ‘group’ all objects together, that have the same text and part of speech. This saves a grate number of unneeded splits while processing the English grammar.
• Made project saving/opening multi threaded so that the UI doesn’t appear frozen.
• Many, many small bug fixes all over the place.

Perhaps a final note, best to uninstall any previous versions.  I haven’t yet tested how the installer works when it overwrites a previous installation, so it might screw things up.  And off course, you can get the new installer from here.

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 undo system is starting to be functional.  There’s still something going wrong with undoing some link operations, but that’ll be sorted out soon probably.
• There’s a new expression type: the global, which is a variable that is able to retain it’s value for as long as a processor is alive.  It’s also possible to determine what should happen with a global during a processor split: copy or duplicate the value, or do nothing. This is done with an outgoing link on the expression, so you can change it dynamically.
• You can now easily attach and edit an unlimited number of code clusters to any neuron from the code editor.  This is useful to attach code to a neuron that shouldn’t be executed directly by the processor (the actions and rules link) but is stored as data, to be retrieved and called from code. Flows for instance use this to attach code that needs to be called by the parser during different stages of the parsing process.
• The debugger is starting to become fully operational with a useful interface.  There are still plenty of quirks that need ironing out, but it’s starting to become useful. Here’s a screenshot of the debugger in action (I’ll explain what everything means and how to use it later on):

  

• Many, many bug-fixes.

The scanner and parser are almost working.  You can already push text to the network, which  is almost parsed into words (some quirks still left).  It doesn’t yet know what to do with the words though (so the link between the scanner and parser is still broken), this is why I needed the extra functionality in the code editor. I’ll explain the scanner and parser’s details in a later post. For now, check out the new release.

• shortcuts ‘N’ & ‘ctrl+N’: add/insert a new neuron.
• shortcut ‘R’: toggle ’selection Required’ for current option/loop.  This is an important feature that I missed (in gene this was no problem since you could use an empty condition which is not possible here).  The problem is this: sometimes,
  an option or loop has to require at least 1 selection between a part (so you can’t skip the condition or flow), sometimes this is not required.  To allow a distinction between the 2, an extra ‘attribute’ is attached to the conditional (the loop or option), much the same as how a selection between loop and option is done.
• I changed the layout from wrap-panel to horizontal stack-panel, which is more logical to work with.

Note: I have updated the table on the first post about the flow editor so it contains the new shortcuts.

I will probably also have to implement a new statement type, to allow for grouping ery soon.  It’s not really needed for defining the flows, but I think it can be useful later on, during the parsing. For instance, the expression: (verb "ing") means that you are expecting a verb, with ing behind (standing, listening,…).  You don’t need the brackets to define it, but it makes more sense while parsing, if the grouping statement has an attribute attached to it that indicates how it needs to be interpreted.

I have also noticed a ‘logical’ error in the way that I implemented keyboard navigation: some keys have been reversed. So when you are on an item inside a part and need to get to that part, use the left arrow instead of the right.  Being able to select
a part is important to continue adding items at the end again when you have added a conditional like in the next image. It’s annoying, but fuck it, this is one for later on.

I’m also not yet very happy with the deletion functionality.  As it is at the moment, you can remove or delete.  Removing simply takes away the reference to a neuron in a list, deleting, will remove the neuron from the brain.  This is annoying, cause you usually want to remove statics and delete conditionals and parts.  If you want to remove an entire condition, you need to first delete all the parts separately.  A better scheme would be as that of the code editor, which will check for this type of situation.  Again, this is a minor thing, so I will add it to the feature list. At the moment, there are more important things to do though.

A bit more interesting, I have also began work on an English grammar definition.  Here’s a screenshot of a part:

It’s off course not a definition that covers the complete language, but I think it should be enough to build a natural language interface, which should be interesting. I’m certain I missed a bunch, I still need to define adverb handling (which will be treated in a pre parser, a bit like how comments are handled in more traditional parsers) and the scanner also needs commencing.  And expect some shuffling around and updates as I implement the parser for this definition.  At this stage, extra attributes will probably be added, to handle more semantically oriented parsing. I have no idea how long this is going to take me, but I expect some issues with the debugger, so I might be out for a week or 2 for the next update.

The editor is still a bit rough, but it should be useful. I’ve tried to make it more text oriented, so you can easily navigate/add/remove items from the keyboard.  In the background though it’s still listboxes so coding the view and data was easy and fast, just that creepy WPF navigation system, off course more importantly, it makes certain no illegal input can be provided.

Anyway, here’s a screenshot:

Basically, this Flow editor describes how a noun can be found in a stream: a noun should start either with an article (which is either ‘a’ or ‘the’) or a number, followed by 0 or more adjectives finalized with a single noun.  Ok, there are gaps here (it’s still a sketch to show the editor): what’s a number, adjective or noun and how to find them.  These things will be explained in the demo, but basically, you use converters (functions that can transform a neuron into another one, like the object ‘house’ into the neuron ‘noun’) or some other info that can be used in a search function which can be attached to the flow items.

To create one yourself, go to ‘Insert/Flow editor‘, use the toolbar button ‘Create new flow editor‘, use the toolbar button on the ‘Project‘ overview tool frame or use it’s context menu. Press ‘F’ to create a new flow followed by a ‘.’ to select a static or ‘['/'{' for an option/loop (press '|' to add new parts in a loop or option). Here's a complete list of available short cuts:

A final note perhaps on how to use these flows in a neural network.  The thing is, this is really up to you, the application doesn’t make any hard-coded use of them. Though, there will probably be a couple of default algorithms that can be reused. 
The basic idea is relatively simple: when the first neuron comes in, search all the clusters to which it belongs with the meaning ‘Flow’, ‘FlowItemConditional’ or ‘FlowItemConditionalPart’ and store the result list in a cluster.  When the second comes in, try to find all the clusters of the previous result set that allow the new neuron to follow the previous one, all clusters that don’t allow this are removed from the result set.  Various clean ups / lookups can be performed during 2 incoming points. When a ‘flow’ cluster is found with code attached to it, execute this. This off course, can be made as simple or as complex as you want. More on this in a later post. Fuel is depleted for today.

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.