Erlang implementation of the spatial pooler


#1

Long time listener, first time caller.

After reading a description (and reading the code) of the spatial algorithms and temporal pooler algorithms on the Numenta website, it struck me that an actor model (ala Erlang) may map well to the SP and TP algos. So I started writing an Erlang implementation of the SP algorithm. I’m far enough along now, that I’d like to share, get feedback, etc…

The basic idea is that cortical cells and input cell are just independent processes (finite state machines) that only communicate through message passing . At start up, I launch N cortical process and M input cells. I leverage the existing Numenta python SP code (via Redis pub-sub) to create a list of links between the input cells and cortical cells. Each input cell (process) has a dictionary containing the process ids of the cortical cells to which it can send messages and a corresponding permanence. Now, imagine we have a input vector, a message is sent from each active bit of the vector, to the corresponding input cells depending on the permanence a series of message are sent to each cortical cell in the input cells dictionary. We calculate overlap by keeping track of how many messages the cortical cells receive, but wait… .

A bit long winded but you get the idea. Now the interesting part, everything in my system is asynchronous; nothing blocks (kinda of like the brain:-). So going back to the calculation of the overlap score, since everything is continuous when do I know if I’ve received all the messages from the input cells; my cortical cells overlap score is a time series not a single number. Has anyone thought of the implications of asynchronous non-blocking HTM system.

Nehal
ps. If anyone is interested, I’ll share the code, PM me. But no comments on the crazy variable names and lack of comments.


#2

I’ve started writing a concurrent HTM implementation myself. I talked about it on another thread: HTM process optimizations

The basic idea is to transmit cumulative small charges between cells. When a certain threshold is met, the cell activates, transmitting a charge to receiving cells. Charges attenuate based on length of the dendrite. A cell’s charge also dissipates over time.

One thing that is required is a timing mechanism to coordinate cells firing. I haven’t gotten that far yet, but my initial thought is to only fire at some predetermined interval using the system clock.

I’ll share my code via the HTM Community on GitHub when I get further along with the idea. https://github.com/htm-community