Otoom banner
Home
Downloads
Books       
Downloads
Whats new              
First-time visitors      
On the origin of Mind 
Synopsis                  
Applying Otoom        
Further developments
The Otoom fractal     
Android                   
CV                         
About
OtoomCM program
OMo program      
OWorm program   
OSound programs 
OVideo program   
Programs Search What's new Parallels FAQs Basic Charter the social experiment Otoom blog List of blog topics Forum Mayaroma Museum Links CauseF program 4g-navcompoundinterest.jpg Contact
LinkedIn icon
Otoom blog
on Facebook
discarded-full-sm.jpg 5g-navtheworm.jpg 5g-navthemindwhats.jpg 5g-navmyhome.jpg 5g-navtheisaa.jpg 5g-navsomething.jpg Freedom uses collective knowledge...
Home  >  AI Programs  >  OtoomCM program

OtoomCM program

The complete guide to the Otoom computer model (OtoomCM) can be found in "On the origin of Mind". There its technical aspects, its functionalities, the behaviour under different conditions, and what it all means as a parallel to neuronal activities, are described throughout the relevant chapters.

The technical aspects and a brief mentioning of the parallels to neuronal and cognitive functions are outlined in the paper "How the mind works: the principle dynamics in the bio- and non-bio version".

The program can be downloaded. Please read the manual!

Following are the main points.

The structure of the system consists of a matrix with its rim allocated to in- and output nodes and the inner matrix nodes being the processors. Each node is another matrix with its nodes called elements and holding integers distributed in a series across the element matrix.

Below is an example how the setup looks like. The main matrix has 8 node rows and columns, and each of its nodes has 2 element rows and columns. The input nodes are red, output nodes are blue, and the inner matrix nodes are green.

Sample structure of matrix

Input is presented to the input nodes (which can be divided into several regions, the same goes for the output nodes), and from there to those inner matrix nodes they are connected to. Each of the inner matrix nodes is the parent node of a virtual tree, with the branchings and depth level determined at the initial setup before starting the program. For example, the parent node (level 0) could be connected to 10 other nodes (level 1), and each of these is connected again to 10 others (level 2), and so on until the desired depth is reached. It goes without saying that such an arrangement makes for a highly interconnected system.

An algorithm processes each element of a node with the corresponding element in its linked node, following the tree structure and moving from one node to the next. The elements in the nodes become changed, and thereby define their node in terms of a phase state in relation to other nodes within a band of affinity relationships that are determined by the degree of congruence between particular nodes.

Finally, certain inner matrix nodes are connected to output nodes and are sending the results of the previous cycles to them. The states of their element matrices (ie, the integer values) can be turned into whatever representation is required. In this case it's circles of a certain colour and size inside an area of the screen.

The main processing steps are shown below.

Main processing steps

The algorithm deals with two integer values at a time - one integer belongs to one element in its matrix and the other belongs to its counterpart in another element matrix (linked via the tree). One value gets changed in relation to the other, and repeating the process gives three possible types of outcome: a stable convergence, an oscillation, or a seemingly random movement of the integer value.

The 3 possible types of integer movements

The algorithm produces chaotic behaviour. It turns an element into an attractor in relation to its counterpart, and depending on the resultant integer values the attractor can be stable, periodic, or strange.

For example, suppose the matrix has 10 node rows and columns, each node 10 element rows and columns, connectivity is 5% (each node is linked to 5% of the total number of nodes), depth level 5, integer values range 1 - 300, and input is '60' at every odd cycle except for cycle 5 where it is '10'. The outputs for every cycle are below. The top row represents the actual images as appearing on the screen, in the bottom row the images are blurred to make it easier to identify the changes.

Sample output

Apart from these images the program offers a wide range of parameters that can be monitored throughout the test runs, and writes text files containing the node states through the cycles. The files can be analysed using a specially written tool.

The behaviour of the integers, the affinity relationships generated, and the overall phase states can be investigated. More details on those can be found in the paper.

The program is a simulation of biological processes. The matrix represents the neuron mass, its nodes the individual neurons; the elements in each node are the protein formations in each neuron; the connectivity reflects the connections among neurons; and the processing algorithm generates values which stand for the neurotransmitters at the synapses. In- and output is distributed to the respective nodes within a particular region according to the relationship between the individual values and the entire value range. Thereby it follows the principles found in the special purpose nerves assigned to specific audio frequencies in the ear, or the visual field-specific receptors on the eye's retina, or the multitude of axons reaching our muscles.

And above all, only one rule (the processing algorithm) governs the main system!

Further development:
To achieve anything approaching intelligent behaviour, the system has to be massively scaled up. Just consider:

- number of neurons in the Aplysia (a kind of sea slug) nervous system: 18,000 - 20,000 (18k - 20k);
- number of neurons in the octopus brain: 300 million (300M);
- number of neurons in the human brain: 100 billion (100G).

In addition, at present the program runs in linear mode. It means that one process cannot begin until the previous one has finished. To cut down on the sheer time needed to go through even one cycle it would have to be transposed into a distributive mode (just like in the biological brain). Since it is written in a highly modular format this shouldn't be much of a problem.

Experiments can be conducted in terms of separate domains, varying parameter Menus for different domains, sensory input for on-going self-evaluation.

Once scaled up, a single matrix can be considered a separate module, linkable to other similar modules. The modules could be connected via a network (such as the internet), thereby turning it into a virtual brain as a whole.

The inputs can come from a variety of sources - optical, aural, any kind of sensors, mechanical. Similarly, the outputs can be linked to a variety of receptors - screens, loudspeakers, mechanical devices.

More on further developments.


© Martin Wurzinger - see Terms of Use