Hi All,
I’ve been following the Thousand brains Project and Monty closely, and I think the approach Numenta is taking iscareful and methodical. The work they are doing is important, mathematically rigorous, and always grounded in neuroscience. But I think in the back of everyone’s minds is the incredible implications of how important a fully complete model of the neocortex and a scalable neocortical intelligence is to the world. It’s something that makes this community unique, is they don’t allow hype to get in the way of good science.
But I want to suggest a complementary philosophy, inspired by how major engineering breakthroughs have often been achieved: **parallel paths**
If you look back in history, the Manhattan Project pursued multiple bomb designs in parallel, some of which never worked, but the redundancy gave confidence that at least one would succeed, and the effort fed back across teams. Operation Warp Speed funded multiple Covid-19 vaccine approaches simultaneously (mRNA, adenovirus, protein subunit) and several worked, but some didn’t. The “wasted” work wasn’t waste, it brought speed.
The pattern is clear, if the stakes are high and the design space is broad, it’s often best to run multiple research paths in parallel.
Path A: The Current Careful Approach
This is what Monty embodies today:
- Metric SDRs, explicit overlap targets
- Graph-based reference frames
- Inspectability and mathematical clarity as first priorities. SDRs have been chosen not to be pursued even though it would simplify voting, because “they are inscrutable”, so one can’t tell if a desirable behavior of the system is attributed to the SDR encoding itself or the feature mapping built around it.
This path builds confidence and makes the science legible to the broader community.
Path B: A Fast-Track Biological Approach
At the same time, we could empower volunteers to push a parallel path:
- Hebbian SDRs with k-Winner Take All competition, phase attractor dynamics for allocentric modelling, direct feature ←→phase binding.
- Less scrutible in the short run, but immediately scalable, closer to biology, and capable of emergent dynamics
- The emphasis here would be: jump straight to scale and performance, accept the messiness, and learn by running it.
This doesn’t replace Path A. Instead it complements it:
- Path B could generate surprising demos that reveal emergent capacity earlier. An impressive demo could lead to more funding and public interest
- Path A provides the intellectual scaffolding to interpret, stabilize, and integrate those results.
The best part: It costs nothing
- There’s already a growing following of motivated volunteers.
- They can self organize around the fast path, while Numenta continues to lead the careful, slower paths.
- Parallelism increases the chance that breakthroughs on one side cross-pollinate the other.
The Proposal
Let’s recognize two parallel design philosophies as equally legitimate and valuable:
- Careful path (Path A): Stepwise, inspectable and mathematically rigorous
- Fast path (Path B): Hebbian, Emergent, Scalable and Biologically plausible even in the areas currently being held back for scrutibility reasons
I’d love to hear people’s thoughts. I’m currently building a feature-phase Hebbian SDR binding
Here’s the current model I’m building for this LM:
Current LM Design I’m working on (Fast path)
The feature SDR would be represented as a vector of bits length D:
The Phase SDR would be generated as follows:
You would have an array of M grid modules. Internally: each grid module is an attractor network that tracks a 2-D phase point, phi_m. That phase is just two floats representing a point on a unit torus. Each one has a different orientation R_m, and scale S_m which is a property of the grid module.
Phi_m can be thought of where the bump of activity sits on a 2D torus. This is not yet a sparse vector. It’s the latent state of grid module g_m.
The next step is to convert phi_m into an SDR system by encoding it.
The phase SDR, g, is a binary array of length B. We can partition g into equal sections for each module. So if B=2048, and M=32 grid modules, we can partition it into 2048/32 = 64 bits per module. Each module “owns” a slice of the SDR vector.
Each bit in that slice has an associated center c_j=(cjx,c_jy). randomly or regularly spread across the unit torus. You can also give each bit a receptive field width sigma_j.
Then we score each phase vector using a scoring function:
Where d_T is the toroidal distance (wrap-around) so the bits near phi_m score high, and far bits score low.
We then pick top k_m highest scoring bits (say 40 out of 2048). Set those bits to 1, the rest to 0.
Now you have a sparse SDR for phase, if you repeat that for each slice
Motion
When the motor moves we update the phase modules with allocentric velocity v
R_m is a fixed rotation vector per grid module, randomly initialized and stays constant
S_m is a fixed scale vector per grid module, randomly initialized and stays constant
v delta t is the x,y translation (open to interpretation of what translation is, but specialized per LM)
modulo 1.0 to loop it around forming a toroidal graph
We can then apply the Phase SDR generation above to get g.
Once we get SDRs g and f, we can make an associative matrix. A
There are two:
A_f→g maps feature SDR to phase, and A_g→f maps phase to feature.
At each timestep we update each feature to phase pair that co-ccurs using this hebbian update function:
where gamma is the decay (forget) rate
and nu is the learning rate.
if g is 2048, and f is 2048, this creates a 2048x2048 bit associative array. We would cap row weight updates so each feature bit only points to a few phase bits.
How recall works
if the agent sees f, then later sees f again,
We project the feature SDR through A to get the phase SDR, and count up the values by row to get a score for each phase bit.
Take the top-k candidate phase SDR ~g.
Blend ~g with current phase SDR g.
This will nudge youyr position toward where the feature expects you to be, enabled allocentric loop closure.
So in short:
Learning is done with hebbian update of feature→phase co-activations
Recall is using learned associations to propose phase bits of a given feature.
Loop closure occurs when the feature SDR recalls a phase different from your path-integrated estimate, blend it, drift is corrected and the map is realigned.
So far this is all speculative annd I have no idea if this design will work. And as a parent with two very young children and a full time job, I haven’t had a lot of time to actually build it. But I’m passionate and excited, and I will post updates once it’s built and I can start experimenting with it!
