In case you are looking for a mental image to visualize this whole concept, try this: Resonance. When a link gets activated (for instance, the one to the very first neuron), it creates a resonance that triggers one or more other neurons. This excitation in turn can cause another link between 2 neurons to be activated, causing more resonance and so and and on until the whole thing settles down.

I have absolutely no prove or idea that this is how it works in the real world, that’s just how my model can be interpreted. Truth be told, this is not how I conceived the thing (aka lets try to create a model that uses resonance), it was rather more like: I have 2 neurons, they are linked, how can I make something happen? Well, I can attach some code to the link and execute that. Cool. But, wait a moment, that looks like resonance…

and we just passed ‘culminate’, pfff

AICI is a chatbot framework, running on a (new kind of) neural network.

Wow, that sounded a lot heavier than it really is. Truthfully, it’s all still in it’s infancy: quite a bit of functionality is missing and I haven’t yet provided it with enough ‘experience’ (aka flows, frames and actions), to be very useful. This results in some limitations and challenges still to overcome. So here are some restrictions for using AICI:

Limitations

• Use simple sentences: subject-verb-object kind of structures, no nested or grouped sentences: I haven’t yet defined enough flows to handle complex sentences (These will come in the ‘English grammar’ flow group).
• Capitals and signs aren’t handled yet (very well or at all). This is a matter of expanding the code a bit, for the capitals, and defining the correct scanner and grammar flows for the signs.
• The network is also not yet able to pick up spelling errors. I have an idea for an algorithm to do this, which would consist out of grouping the letters together in front, middle and back, but that’s just an idea at the moment.
• Compound words (like ‘English grammar’) aren’t recognized (again). These are important cause the thesaurus is full of them, and they provide good shortcuts, I think. So I did implement that, and then overrode the code, so I’ll have to do that again. Bummer.
• It’s not yet able to automatically generate frames, flows and actions. Again, I have a couple of ideas for this, but it’s still a bit to soon for that. So you currently have to ‘train’ networks by manually creating frames, flows and some code.
  The lack of this algorithm unfortunately,results in improper error handling. That is to say, some situations currently simply generate a ‘Confusion’ or ‘Don’t know’ kind of output. This usually means that the network found unknown input and should try to generate new frames/flows and or actions.

Small recap:
Both frames and flows are used to define ‘known’ or ‘recognized’ sequences in the input. Frames use restrictions to filter out data and can only handle a fixed nr of simple sequences. They were inspired by VerbNet and FrameNet. Flows are more flexible, they can define optional and repetitive parts. Their origins go back to Coco/R and Gene.

How does it work

There are basically 4 stages at work, to get from letters to a response. The first 2 have already been covered in the scanner demo. These are used to transform letters into words (the scanner view, which contains flows) and words into grammatically understood sentence parts, like: subject, verb,… (that’s the English grammar view, which are also flows). The transformation between those stages is done by code, that’s part of the framework (so it’s all neurons). Basically, this is the syntax recognition stage.

The new stuff starts from here: From the grammar, we do a translation process to the frames and these in turn trigger actions, which finally ‘do’ something, like render some output, store information and/or trigger an external process.

Reminder:
A logical neural network, is a free form network (all link combinations are allowed), which functions on the basis of resonance: a link traversal can activate other parts of the network. It’s roots can be traced back to interpreters and databases.

Actions are able to handle different moods and time frames. This means that the same action can result in a different result, depending on the condition/state of the system. Furthermore, frames provide ‘time’ info (passed, present, future), which can also be handled differently by the actions. There’s a very simple reason for this: actions are all code. So unlike flows and frames, which you can declare, the actions need to be programmed.

The important thing to note here is that it’s all done by neurons, so code, frames, flows,… are all neurons, and everything that can be done with neurons from the designer, can be done through code (in fact, the latter can do quite a bit more). This means that it should be possible to create actions that are able to generate frames/flows/actions. Unfortunately, I am not that far yet.

About the code

I’ve been doing a lot of thinking on how best to explain this. First of all, it’s very dry stuff. Most people probably aren’t interested in the guts of the thing and just want to get working with it.  Possibly, quickly add some of their own functionality and be done with it. Furthermore, I’ve been debugging this thing for so long now, it sort of started to grow on me. I now how it works by now. So I’m ok. Off course, you do need to know some details to get the most out of it. So I decided to, instead of explaining every single neuron in the code, I would simply give you the algorithm that I used for coming up with it in the first place. From than on, I could simply show some step by step techniques to add new functionality. So here goes:

To build an algorithm, I first tried to find the path from start to end neuron/status/situation/.., that should be traversed. Then, each step is focused upon individually, to find out ‘what’ needs to be done to get from A to B. For instance, image you have a text neuron, that contains the value ‘Jan’. If I need to find the flow that fits this input, I need to first find out which part of speech it is (POS=verb, noun, adverb, adjective,…). This can be found through an outgoing link on the text neuron, with the meaning ‘POS’ (this is an agreed upon convention, it could be declared differently, which is the case, the point is that it should always be done in the same way in a single network). Once I have that, I can query for all the ‘flows’ or ‘flow parts’ in which this pos value is used. Perhaps the ‘Noun’ pos is declared in the ‘subject’ and ‘object’ flows. In this case, we do a split and evaluate further. Eventually, one path of the split should die out (if it doesn’t, we currently have a ‘confusion’, but it should end with the addition of a new filter somewhere, or similar), and we can render some output.

Reflection:
As a neuron, I can see links coming in from the left, going out to the right, and when I look up, I can see all the clusters I belong too. If I am a value neuron, I can store something in my belly, and if I am a cluster, and look down, I can also see all my children.

I still need to to a little fixing to AICI (the new storage system has uncovered some more bugs in the network code) and than I’ll continue with some hands on examples on extending the functionality,.. stay tuned.