I have an idea for Simplified implementation of Grid cells layer, may be !!
You decide if I’m bit too clever for the wrong reason 
What is left is the easy part i.e. how to ENCODE/DECODE this thing 
to/from SDR ?
lets start with some snippets from the paper .
To form a unique representation requires multiple grid cell
modules with different scales or orientations (Figures 1C,D).
For illustration purposes say we have 10 grid cell modules and
each module can encode 25 possible locations via a bump of
activity. These 10 bumps encode the current location of the
animal. Notice, if the animal moves continuously in one direction
the activity of individual modules will repeat due to the tiling, but
the ensemble activity of 10 modules is unlikely to repeat due to
the differences in scale and orientation between the modules. The
representational capacity formed by such a code is large. In our
example the number of unique locations that can be represented
is 25 10 ≈ 10 14 .
To summarize the above properties, a set of grid cell modules
can unambiguously represent locations in an environment.
These locations can be path integrated via movement, and
environmental landmarks are used to correct path integration
errors. By choosing random starting points within modules,
unique location spaces can be defined for each environment. The
space of all possible cell activations grows exponentially with the
number of modules, thus the capacity for representing locations
and environments is large.
So required property number one “unambiguously represent locations” i.e. many unique locations.
The idea is to use MODULO operation as a grid-module.
F.e. if we select 3 prime numbers 5,11,13 … we get unique location-coords, based on the reminders.
Second the loc-ids are tiled courtesy of mod-operation.
Third if you return back at a position you get the same unique ID.
Forth adding more primes increases the capacity.
Fifth starting from random value (position) gives us different sequence of reminders as we move around i.e. different maps
In [515]: [(i,list(i % np.array([5,11,13]))) for i in range(50,60)]
Out[515]:
[(50, [0, 6, 11]),
(51, [1, 7, 12]),
(52, [2, 8, 0]),
(53, [3, 9, 1]),
(54, [4, 10, 2]),
(55, [0, 0, 3]),
(56, [1, 1, 4]),
(57, [2, 2, 5]),
(58, [3, 3, 6]),
(59, [4, 4, 7])]
The first question that remains is how to ENCODE/DECODE the location-coords to/from SDR ?
This is 1D representation of integers i.e. if used to create grid-layer beside scaling it to N-dims we have to solve the problem of nudging it based on feedback from the Sense layer.
Here is how we do that :
1. decode the sense-SDR
2. using the reminders (location-coord) as input to Chinese-reminders-theorem with pairwise-coprimes (primes fit the bill) recover the integer value
Why this could work ? For 1D-integer MOVE-commands could be +X and -X steps, so we do not feed the command directly but instead calculate :
Curr-1D-pos + Move = new-pos
and pass this value as input.
The structure is :
|=----------------------------->|
[ L4-TM ] <=-=> [grid mod] <=-=> [ L6-TM ]
Let say we start with 55 :
init pos = 55
loc = (0,0,3) /modulo op/
convert loc => SDR1
pass SDR1 to L4 TM
sense SDR2
L4 TM : learn SDR1 => SDR2
pass SDR2 to L6 TM
move = +1
pos = 56
loc = (1,1,4)
conv loc => SDR3
predicted = predict(SDR2) /TM of L6/
merge = predicted * SDR3 => SDR4
reminders = conv(SDR4)
new_pos = CRT(reminders)
nudge : pos = new_pos
L6 TM : learn SDR2 => SDR4
):
