Creating Emulations of Nervous Systems

   Let me begin this post by stating that what is contained within is a simplified idea of the actual coding and there are specifics I am leaving out due to the amount of information would be better contained in a book rather than a blog post. Here I am attempting to highlight concepts and not discuss in detail. Maybe later discussions will allow me to do so? 

The key with emulations of nervous systems is real time emulation if you are wanting real life AGI

The first order of emulation is machine constraint. When I first did connectomic experiments, pretty much every machine I worked with could only support 250 processes running at a given time (16-bit). I had lunch with a colleague one day in 2013 complaining about this limitation when he asked, "Don't you have a 32 bit system now?". I did so he told me that he bet I could have many more processes running under that architecture. When I got home, I created a quick app that started up 302 notepad.exe and there were no issues! That's when I created a single program that would emulate a simple neurite and started 302 of those neurite programs, each representing one of the 302 neurites of the C elegans nervous system, and applied to the EV3 robot. 

Therefore, emulation One (1) is using an individual program to emulate a single neuron, connect those neurons together through messaging (in my case UDP) and thus create a complete emulation of a nervous system. This allows complete asynchronous, parallel processing for the entire emulation. The problem with this emulation is two-fold (as earlier discussed): 1) you can only run so many individual programs on a single system before it gets bogged down with too many apps and so much emulation, and 2) your messages begin to stack because they begin having messages being received at such a high rate. I always wanted to use maybe 300 Raspberry Pis and make each one a neuron to see what I could gain?

Emulation Two (2) I've used is to place all the neurons into an adjacency matrix where one can apply the row of the matrix as a vector to accumulate the weights as the neurons fire. Like Emulation 1, we also have machine limitations due to the recurrence of neuronal activity. Once you have a large matrix, there are so many calculations going on, single systems have a difficult time doing anything real time. In addition, depending on memory, you can only size an adjacency matrix so big. I found with a 16GB system, you can only have a matrix of around 16K+ neurons before the system won't allow any more. Also things like the language you are using, etc puts constraints on an app that is all self contained. 

I have created and many others have used, a single Python program that will emulate the C elegans connectome quite well. However, when one starts to try and create a system much larger than 300 neurons, the system paralyzes pretty fast. 

Here is a video of a robot using a single Python app to emulate the C elegans nervous system: 

https://youtu.be/KhuSDjURIaA

The problem isn't emulation, the problem is machine constraint

You can see a couple of emulations we have as NFTs at OpenSea.io here:

PROME - Collection | OpenSea

The NFTs are OpenSea.io, one is the C elegans emulation with 302 neurons, the other is a Drosophila emulation with 7400+ neurons. The latter is almost completely paralyzed running so many neurons on one system.

Emulation 2 can also be put into the mathematical formula method. I know a lot of researchers use a formula to calculate the outcome of neurons instead of linear algebra but both matrix/calculus suffer from the same issue which is all calculations are based on a clock step. There is no real independence of an individual neuron and I would call a simulation and not an emulation. Simulations have their place and can be quite useful for neuroscience but I personally believe we need connectomic emulation to achieve AGI.

The Third (3) emulation is a hybrid model of the two above which I am using currently with some success. Because my emulations now consist of tens of thousands of neurons, I needed a more practical approach and will allow for real time emulation. Therefore, I am working with breaking up neuronal groups into single programs that message one another. For example, a C elegans emulation might be three programs: Sensory, Interneuron and Motor, each containing the neurons in a matrix that represent the functional grouping. 

Emulation 1 and Emulation 3 can also be divided amongst many computers. Using UDP messaging, I can also use IP Address and Port so that the workload of each Functional app is divided and not all running on the same system. Emulation 3 seems to be the best method I currently have to emulate connectomes like that of Drosophila = ~100K neurons.

Another issue I find with any emulation is one must tweak the parameters to fit the system. For example, one Functional app may need parameters placed higher with another lower due to the amount of interactions going on due to recurrence and the amount of neurons in the functional group. Where one might put a hyperpolarization threshold on one app at 500ms, I may have to put that at 700ms in another to allow for more heavy traffic. An analogy would be having two cars come to your house at the exact same arrival time from two different originating places. One might be traveling through very congested traffic whereas the other with relatively light traffic. You might need to have the one in light traffic travel at 45 mph rather than 65 mph in order to balance things out. This is very tricky to say the least and one I strive to have automated over time. 

I must note that Emulation 1 is the best method I have found that truly emulates a nervous system because each app is independent and from my experimental observations, gives a robot what appears to be a true biological experience. As noted, this is not practical with huge connectomes unless one has the ability to run thousands of computers at one time.

I will discuss plasticity in a later post but one can develop plasticity with any of the emulation models discussed above. This includes synaptic strengthening and weakening as well as synaptic growth and pruning.

If you have any ideas on how to emulate in better ways, please share! I am always looking to make these emulations successful in order to create systems that are true AGI, real time systems. Obviously this is necessary for the future of AI and human interaction.