No Free Lunch from Deep Learning in Neuroscience: A Case Study through Models of the Entorhinal-Hippocampal Circuit
Abstract
Research in Neuroscience, as in many scientific disciplines, is undergoing a renaissance based on deep learning.
Unique to Neuroscience, deep learning models can be used not only as a tool but interpreted as models of the brain.
The central claims of recent deep learning-based models of brain circuits are that they make novel predictions about neural phenomena or shed light on the fundamental functions being optimized.
We show, through the case-study of grid cells in the entorhinalhippocampal circuit, that one may get neither.
We begin by reviewing the principles of grid cell mechanism and function obtained from first-principles modeling efforts, then rigorously examine the claims of deep learning models of grid cells.
Using large-scale hyperparameter sweeps and theory-driven experimentation, we demonstrate that the results of such models may be more strongly driven by particular, non-fundamental, and post-hoc implementation choices than fundamental truths about neural circuits or the loss function(s) they might optimize.
We discuss why these models cannot be expected to produce accurate models of the brain without the addition of substantial amounts of inductive bias, an informal No Free Lunch result for Neuroscience.
Based on first principles work, we provide hypotheses for what additional loss functions will produce grid cells more robustly.
In conclusion, caution and consideration, together with biological knowledge, are warranted in building and interpreting deep learning models in Neuroscience.
Introduction
Over the past decade, deep learning (DL) has underpinned nearly every success story in machine learning, e.g., [49, 5] and increasingly many advances in fundamental science research, e.g., [29].
In neuroscience, DL is similarly gaining widespread adoption as an indispensable method for behavioral and neural data analysis [45, 43, 23, 37, 34, 40].
But DL offers a unique contribution to neuroscience that goes beyond its role in other fields, in that deep networks can be viewed as models of the brain.
The success of DL in matching or surpassing human performance suggests it is now possible to construct models of circuits that may underlie human intelligence.
As a recent review wrote, “researchers are excited by the possibility that deep neural networks may offer theories of perception, cognition and action for biological brains.
This approach has the potential to radically reshape our approach to understanding neural systems" [46].
Further, DL is a democratizing force for building neural circuit models of complex function.
The essential claims (and promises) of DL-based models of the brain are that 1) Because the models are trained on a specific optimization problem, if the resulting representations match what has been observed in the brain, then the models reveal which optimization problem(s) the brain is solving, or 2) These models, when trained on sensible optimization problems, should generate novel predictions about the brain’s representations and behavior.
However, given the nascent nature of such approaches and the excitement accompanying some claims, we should examine them carefully.
In DL, some successes attributed to novel algorithms have been shown to instead stem from seemingly minor or unstated implementation choices [57, 17, 28].
In this paper, we ask whether Neuroscientists should similarly be cautious that DL-based models of neural circuits that make specific claims about revealing the brain’s optimization functions or that predict specific neural tuning curves may tell us less about fundamental scientific truths and more about programmers’ particular implementation choices, and might as a result be more post hoc than predictive.
To explore these questions and point toward a systematic and circumspect use of DL for Neuroscience, we evaluate recent DL-based models of grid cells in the entorhinal-hippocampal circuit.
The medial entorhinal cortex (MEC) and hippocampus (HPC) are part of the hippocampal formation, a brain structure critical for learning and memory.
In a pair of Nobel-prize winning discoveries, HPC was shown to contain place cells [42], and MEC, its cortical input, was shown to contain grid cells [25].
Place cells fire at one or several seemingly random locations in small and large environments [44], while grid cells fire in a spatially periodic pattern in all two-dimensional environments, whenever the animal is at the vertices of a hexagonal lattice [25].
Over five decades, the hippocampal formation has been central to understanding how the brain organizes spatial and episodic memory, for experimentalists and theorists alike, with many mysteries remaining.
A recent series of DL-based models of the circuit [13, 3, 51, 60, 41]) present a story that training neural circuits on path integration (PI) (i.e., the task of estimating one’s spatial position in an environment by integrating velocity estimates) results in the emergence of grid cells.
We use public code from prior publications to demonstrate these results are due to implementation details that tell us more about those choices than they do about MEC.
By leveraging theoreticallyguided large-scale hyperparameter exploration and hypothesis-driven experimentation, we show:
Networks trained on path integration tasks almost always learn to optimally encode position, but almost never learn grid-like representations to do so.
The emergence of grid-like representations depends wholly on a specifically chosen encoding of the supervised target, not on the task itself, and these choices may be unrealistic.
The chosen encoding requires many other sensitive hyperparameter choices, such that small alterations result in loss of grid-like representations.
Grid periods and period ratios depend on hyperparameter choices and are not set by the task.
Multiple grid modules, a fundamental characteristic of the grid cell system, do not emerge.
In short, deep learning models of MEC-HPC yield grid-like units only when many specific and biologically implausible implementation choices are made, intentionally baking grid-like units into the task-trained networks, and the emergent grid-like units lack key grid cell properties.
It is highly improbable that DL models of path integration would have produced grid cells as a novel prediction from task-training, had grid cells not already been known to exist.
Moreover, it is unclear what interpretability or understanding these models contribute, beyond or even up to what has been shown for these circuits by existing models.
These results challenge the notion that deep networks offer a free lunch for Neuroscience in terms of discovering the brain’s optimization problems or generating novel a priori predictions about single-neuron representations, and warn that caution is needed when building and interpreting such models.
[Figure]
Our work benefited greatly from previous publications that published their code, for which the authors should be commended.
By building on their code, we have been able to present novel insights that we hope will contribute to a clearer understanding of the potential risks and rewards of using and interpreting DL models in Neuroscience.
To facilitate further research, we similarly release code 1 .
Background: Grid Cells
Grid cells [25] are found in the medial entorhinal cortex of mammals and are tuned to represent the spatial location of the animal as it traverses 2D space.
Each cell fires at every vertex of a triangular lattice that tiles the explored space, regardless of the speed and direction of movement through the space.
As a population, grid cells exhibit several striking properties that provide support for a specialized and modular circuit.
Grid cells form discrete modules (clusters), such that all cells within a module share a common period and orientation, while different modules express discretely different spatial periods [54].
The period ratios of successive modules have values in the range of 1.2-1.5.
The mechanism underlying grid cells is widely supported to be through attractor dynamics:
Translation-invariant lateral connectivity within the grid
cell network results in a linear Turing instability and pattern formation [8, 19, 6].
These models explain how grid cells can convert velocity inputs into updated spatial estimates, and make several predictions that have been confirmed in experiments, including most centrally the stability of low-dimensional cell-cell relationships regardless of environment and behavioral state, that define a toroidal attractor dynamics [20, 61, 56, 22, 21].
Experimental approach
Path integration (PI) is the task of using self-velocity estimates to track one’s spatial position, a crucial component of spatial navigation.
The central message of existing DL models of grid cells is that training ANNs to path integrate causes the networks to learn grid cells [13, 3, 51, 60, 41].
We follow the setup used by many previous papers: a 2.2 m x 2.2 m arena is created, then, spatial trajectories (i.e. sequences of positions and velocities) are sampled.
Networks receive as inputs the initial position and velocities, and are trained to output (a possible encoding of) the positions in a supervised manner (Fig. 1ab).
There are multiple possible encodings of position, and, as we will show, this choice is critical.
Two simple encodings are Cartesian [13] or polar [1].
Another encoding scheme is via bump functions in 2D space, with each output assigned a single different position that collectively tiles the space and all outputs assigned identical tuning curves [3, 51, 51, 41].
This encoding has been equated with place cells, even though place cells’ fields tend to be heterogeneous in size and shape [44, 15], as well as in number [44], and, unlike the choice of a difference-of-Gaussians (DoG) or difference-of-Softmax (DoS) readout tuning in ANN models, do not exhibit any inhibitory surround.
See Appendix A for position encoding details.
For all encodings, supervised learning is used to train the network via backpropagation through time.
[Figure]
Spatial tuning assessments The spatial tuning of hidden units in the networks, visualized as ratemaps, is the primary method for comparison with the brain’s grid cells.
To compute ratemaps, a trained network is evaluated on long trajectories that cover the 2D environment, then each hidden unit’s activity is binned against the true position in the environment, and counts per bin are normalized by the number of visits to that bin.
Ratemaps of units are compared with grid cells through the gridness score.
We are extremely lenient with classifying a training run with particular hyperparameters a success: if even a *single* hidden unit has a grid score above a certain threshold, we say the model possibly possesses grid cells.
The grid score is not perfect since cells classified by grid scores represent only an upper bound on the total number of grid cells.
For details, see Appendices B and C.
Networks trained on path integration tasks learn to estimate position, but rarely learn grid cells
As [51] wrote in their section titled “Optimally encoding position yields diverse grid-like patterns,” “Why do these diverse architectures, across diverse tasks (both navigation and autoencoding), all converge to a grid-like solution, and what governs the lattice structure of this solution?”
In contrast, we demonstrate that most networks do not converge to a grid-like solution, instead requiring very specific readout tuning functions and hyperparameter choices.
Grid-like representation emergence is determined by choices made by the programmer that, rather than relating to the path integration objective or biologically realistic place cells, is designed post hoc to produce grid cells.
We ran large-scale hyperparameter sweeps across common implementation choices: 1) Architectures:
RNN [16]; LSTM [27]; GRU [11]; UGRNN [12]; 2) Activation: Sigmoid; Tanh; ReLU; Linear; 3) Optimizers: SGD, Adam [35]; RMSProp [26] 4) Supervised Targets: Cartesian; Polar; highdimensional bump-like readout population code with Gaussian [3], Difference-of-Softmaxes (DoS) [51, 52, 41] or Difference-of-Gaussians (DoG) tuning curves.
5) Loss: mean squared error on the agent’s
Cartesian position [30, 13]; geodesic distance on the agent’s polar position [1]; cross entropy on a high-dimensional population of bump-like readout units [3, 51, 41] 6) Miscellaneous: recurrent & readout dropout, initialization, regularization, seed.
For networks with bump-like population readouts, we additionally swept: 1) Field width σ , i.e., standard deviation of the Gaussian tuning curve (often denoted σ E def =
σ in the literature); 2) Whether the bump-like readouts have homogeneous or heterogeneous field widths; 3)
In the case of readouts with
[Figure]
DoG or DoS tuning curves, the surround scale s , i.e., the ratio between the inhibitory and excitatory
Gaussian’s standard deviations ( s def = σ I /σ E ); 4) Number of fields per readout unit.
Evaluating the entire hyperparameter volume is computationally prohibitive, so we evaluated a subvolume most consistent with previous papers, focusing on perturbations from hyperparameters that did produce grid cells.
In this sense, our search was biased toward configurations shown to produce grid cell emergence and thus our findings about the fragility of these solutions conservatively favored these solutions as much as possible.
All sweeps are provided in Appendix E.
To evaluate whether a network learns to optimally encode its position, we measured its position decoding error using previous papers’ method [3, 51, 41]: we computed position decoding error using the network’s output Cartesian positions (if trained on Cartesian targets) or by decoding position from the network’s outputs.
Any network with error < 10 cm was considered to have achieved optimal position encoding; this threshold was chosen based on noise inherent in the decoding algorithm.
In total, we trained > 11 , 000 networks and found that most hyperparameter configurations succeed in learning to path integrate (Fig.
2a, Top), but few learn grid cell representations (Fig.
2a, Bottom).
This is consistent with earlier work [30, 1] demonstrating that networks can learn to path integrate and solve other navigational problems (e.g. estimating which of several environments correspond to the current location) without grid-like units emerging as a solution.
Grid-like unit emergence requires a highly specific choice of supervised target encoding
We next sought to characterize when grid cells are learnt under different encodings of the supervised target, i.e., 2D position.
We tested multiple encodings: i) Cartesian, ii) Polar, iii) Gaussian, iv) a very specifically selected Difference-of-Softmaxes (DoS) readout and more.
We found that grid cells do not emerge from Cartesian, Polar or Gaussian encodings (Fig. 2abc), consistent with earlier work [30].
Only by choosing a DoS readout tuning curve did grid cells sometimes emerge.
5.1 Grid periods are parameter-dependent, and multiple modules do not emerge
Next, a prominent feature of grid cells that is critical for their unambiguous encoding of position over large scales is the existence of a discrete set of grid periodicities, which tend to scale by a rough factor of 1 . 4 between adjacent scales [54].
We asked whether ANN models generate multiple periods and when they did so, what hyperparameters and other choices the formed periods depended on.
To ensure we would obtain at least some grid cells, we fixed the readouts to be DoSs, and swept over different scales of the DoS. We found that almost all runs had a unimodal distribution of grid periods (Fig. 3a), meaning the networks learnt only one module of grid cells.
During the NeurIPS review process, other researchers independently found the same result [48].
[Figure]
Further, we found that the period of the formed grid-like representation is completely determined by the scale σ E of the externally imposed readout DoS (Fig. 3).
The period of the grid-like responses in every run increased monotonically with the width of the DoS readout (Fig. 3b).
Since the models did not result in multiple modules in a single network, we used the somewhat discrete distribution of peaks of the single module formed when sweeping the DoS parameter more continuously to compute grid period ratios.
These period ratios from adjacent peaks led to non-biological values (Fig. 3c).
5.2 Fourier analysis of Turing instability explains the preceding empirical results
Why do only Difference-of-Softmaxes (DoS) readouts produce grid-like units?
We restate the essence of previous analyses of first-principles models [8, 32] here, and explain why they might explain our findings.
In a recurrent network with dynamics ˙ r ( x ) = − r ( x ) + g ( W ⋆ r ) , where x designates the neural index (in a continuum approximation for neurons), W ⋆ r designates the total (integrated) inputs from the network to the neuron at index x , and g is the non-linearity, if the recurrent weight interaction is translationally invariant, then W ( x, x ′ )
=
W ( x − x ′ )
=
W (∆ x ) .
Under DoG interactions:
W
[Equation]
where ∆ x refers to the difference of indices between the neural pair linked by the weights.
The evolution of activity can be decomposed into the growth and decay of Fourier components of the rate vector, which is fully determined by the Fourier transform of W , which is given by:
[Equation]
Here α E ( α I ) denotes the strength and σ E ( σ I ) denotes the scale of excitation (inhibition).
For linearized dynamics that approximate ˙
r ( x ) ∼ − r ( x ) + f (∆ x ) ⋆ r (i.e., g has been linearized), the solution will be periodic if the maxima of ˜ f
( k ) , given by [ k ∗ ]
[Equation]
contains sufficient power and if k ∗ ̸ = 0 .
Specifically, the condition for pattern formation is ˜ f
( k ∗ ) >
In particular, the inhibitory surround contained in f (∆ x ) , with strength σ I , is key to pattern
[Figure]
formation; if σ I → ∞ or α I → 0 , the maximum is at the origin ( k ∗ = 0 ), causing no pattern formation.
Therefore, a Gaussian interaction cannot produce periodic patterns.
The connection of this theory to ANNs trained with supervised readout target P was made in [51] through the observation that dynamics with an MSE loss
||
P − W readout r || 2 can be approximated as ˙ r
= − λr + Σ r where Σ = PP T is the readout correlation matrix and λ is a regularization parameter.
This dynamics now looks identical to the first dynamics with recurrent interaction matrix
W ( x, x ′ ) =
Σ xx ′ .
For identical, unimodal target readout functions with DoG tuning curves, this readout correlation matrix is also a difference of Gaussians (Appendix D).
By the same theory outlined above, Gaussian tuning curves should not produce periodic patterns.
5.3 Unmentioned implementation detail matters
We discovered a seemingly minor implementation detail in several preceding papers [51, 52, 41] that proved necessary for the emergence of grid cells, that (to the best of our knowledge) is not mentioned in the main texts nor supplements.
While these papers nominally refer to a Difference-ofGaussian (DoG) readout target function (Eqn. 1), their code instead uses a Difference-of-Softmaxes (DoS) target function.
When we trained ideal grid-forming ReLU networks on place-cell-like target encodings with DoG tuning curves, sweeping the receptive field σ and surround scale s , DoG readouts did not result in grid cells (Fig. 4b), while DoS readouts did.
The preceding Fourier analysis shows why DoS tuning, though still more unrealistic as a place cell model than DoG, matters (Fig. 4c).
Grid cells disappear with more biologically-realistic readout functions
Place cells, to which grid cells project, differ significantly from the highly simplified single-scale, single-field ANN readouts.
Place cells have heterogeneously distributed field widths, many with multiple fields [44, 15] (and are not DoS-like functions).
This naturally leads to the question: Will readouts targets with multiple scales and multiple fields per place cell still produce grid cells?
We found that networks trained with multiple-field multiple-scale bump encodings per readout unit achieve comparably low position decoding error as good single-field single-scale encodings (Fig. 5a), but do not learn grid cells (Fig. 5bc).
This further demonstrates that accurate position encoding and integration do not require grid representations.
Why path-integrating ANNs might achieve high predictivity of MEC data
We conclude by introducing a puzzle.
A recent NeurIPS spotlight [41] notes that networks trained on single-field single-scale DoS readout encodings explain variance in mouse MEC neural activity at nearly 100% of variance explained by other mice.
In contrast, our results demonstrate that these networks learn few grid cells and produce unimodal grid period distributions inconsistent with biological grid cells, and require readout encodings inconsistent with biological place cells to do so.
How are these networks able to predict mouse MEC neural activity so well?
The neural data is not public and the analysis code is not open source, so we are unable to investigate this puzzle.
However, we offer a conjecture with preliminary evidence.
The analysis of [41] linearly regressed rate maps from one agent (mouse or network) onto rate maps from another mouse, and used
Pearson correlation as a measure of “neural predictivity.”
We conjecture that different architectureactivation pairs achieve different neural predictivity scores because different pairs learn different intrinsic dimensionalities that then provide richer/ poorer bases for linear regressions.
To explore our conjecture, we trained [41]’s 5 architectures (RNN, LSTM, GRU, UGRNN, SRNN) with ReLU activations, with 5 seeds per architectureactivation pair.
For each trained network, we extracted rate maps and computed a standard linear measure of dimensionality called participation ratio [36], then plotted each pair’s average participation ratio against the published neural predictivity.
We found networks with higher dimensional rate maps have higher neural predictivity (Fig. 6).
We caution this correlation between dimensionality and neural predictivity is not strong evidence.
However, we predicted that similar results would be found in other species and modalities (e.g., vision, audition), and during the NeurIPS review process, two independent research groups confirmed our predictions in macaque vision [2] and human audition [58].
If our conjecture is correct, it raises an important research question of whether linear regression-based comparisons of ANNs with neural data might produce better matches to biology more because
ANNs have higher dimensional representations than competitors, rather than because of a detailed similarity.
We hope this section will spur further analysis of methods to compare artificial and biological networks.
Discussion
claims of recent of
For research that uses deep networks as models of the brain, there is a fundamental obstacle to making the claim that a given optimization problem is what the brain is solving: If we know the responses of a significant fraction of units from biological networks performing a certain task, we cannot infer the loss function that the brain is optimizing since in principle, numerous different loss functions can have the same/similar minima (Fig. 7 top).
In other words, there is typically a many-to-one mapping between loss functions and some point in state space where the functions have a minimum.
Some of the different grid models from deep learning and first principles show that this is possible [13, 3, 51, 60, 8].
Conversely, given a reasonable optimization problem that we select based on an organism’s ecological niche, we cannot infer a single solution (and thus build truly predictive single-cell tuning models), since there exist several minima to that optimization problem (Fig. 7 bottom).
In other words, there is typically a one-to-many mapping from a loss function to its set of solutions.
To break this uniqueness problem and arrive at truly predic- tive models or a better understanding of the brain’s optimization problems, we must acknowledge, understand, and model the specific inductive biases and constraints present in the biological system we are trying to model.
It is untenable to expect success without doing so.
This is what we refer to as an informal neural ‘No Free Lunch’.
These constraints and biases are as informative as other design principles such as the loss function.
What can we learn from DL models about brain circuits without considering and studying biological inductive biases?
Population-wide low-dimensional latent representations and dynamics that arise as necessary for solving difficult problems are possibly sufficiently robust and abstracted to be predictive of population dynamics in a neural circuit without addition of detailed biological constraints.
Examples include population-level analyses of the visual pathway [31, 4], as well as the populationlevel low-dimensional dynamics of circuits solving inference tasks [55, 47, 1, 59].
In these cases, the emergent solutions involve fundamental features or latent representations that are necessary for solving the task, and need not be specific to tthe brain; for instance, if the task involves finding pink objects, then there will be representations tuned to pink objects, regardless of whether the system solving the task is neural.
Returning to grid cells, we have shown that they do not generically arise in networks trained to path integrate.
Theoretical first-principles work on grid cell representations [18, 53, 39] suggests that the following two factors are important features of the code beyond path integration: a very large coding range and the related property of robustness/intrinsic error correction, both of which have been shown to translate into the problem of packing and maximally separating a large set of coding states within a compact coding space [53].
Adding these properties to the loss is likely to be a more principled and simultaneously more interpretable way to obtain grid-like units rather than by hand-designing a biologically unrealistic DoG or DoS readout.
Consistent with this, the very large amount of dropout or other noise required in [3, 13] suggests that the coding-theoretic insight on intrinsic error-correction properties of grid cells and their related large capacity might indeed be central ingredients to produce grid cells.
We hypothesize that key properties of the grid cell code elucidated earlier by theoretical arguments, including but not limited to path integration, may form a sufficient and biologically relevant set for the emergence of grid cells: 1) non-negative activations; 2) equivariant population responses (i.e., the population response always lies on a hypersphere); 3) a path integrating (PI) code or in other words, translation invariant representations [19, 8]; 4) high representational capacity [7, 53, 38]; 5) intrinsic error-correcting capabilities [7, 53]; and finally, 6) uniformly distributed (whitened) and low spatial information per cell, such that the total spatial information of the grid code should be equally distributed across all cells.
We suggest that several of these properties (excluding the more grid-cell specific property) are extremely general features or inductive biases of neural codes, and could increase the ability of ANN models to make de novo rather than post hoc predictions, thereby removing the need to use synthetic and unrealistic architecture choices (such as DoG and DoS readouts).
For recent promising work, see [14].
First-principles continuous attractor network (CAN) models of grid cells made several novel predictions that have been confirmed in experiments [33]: the invariance of cell-cell relationships regardless of environment and behavioral state (constituting, in the terminology of machine learning, “far out of distribution” tests of the models) that define an invariant toroidal attractor manifold [61, 56, 22, 21] and grid-like patterning in the cortical sheet [24].
Deep learning-based models should be held to similar standards.
In sum, the central contribution of scientific interest when building and studying ANN models of the brain that reproduce specific tuning curves is not that the model produced the curves (after all, given the expressive power of deep networks, it is no revelation that training them to generate a given tuning will in fact succeed), but rather to explore and carefully characterize conditions and constraints under which the particular tuning does and does not emerge, to explicitly consider which inductive biases in biology are relevant, and to examine what principles and de novo predictions can be extracted from the models.
When not predicting specific tuning curves, but rather population-level response dynamics, the results are expected to reflect the key latent variables required to solve the task.
These relatively brain-agnostic features are more robust to specific implementational choices, and thus as predictions more likely to be durable.
Acknowledgements
This work was supported by the ONR, the NSF, the Simons Foundation through the Simons Collaboration on the Global Brain, and the Howard Hughes Medical Institute through the Faculty Scholars
Program.
MK was supported by the MathWorks Science Fellowship.
A Position Encodings
Suppose we sample a sequence of positions x 0 , ..., x T ∈ R 2 and a sequence of velocities v 1 , ..., v T ∈ R, where x t = x t − 1 + v t .
We want to train the networks in a supervised manner to predict (a possible encoding of) their position.
We used the below encodings as different regression targets.
For some encodings that required place cell populations, we denote the number of place cells N p and denote their locations { p i } N p i =1 , sampled uniformly at random within the 2.2 m × 2.2 m arena.
• “Low-dimensional" Cartesian: x t • “High-dimensional" Cartesian: Let A ∈ R N p × 2 , b ∈ R N p have entries sampled i.i
d. from Uniform ( − 1 , 1) .
The target is a vector in R N p given by:
[Equation]
• Polar: Let ( r t , θ t ) denote the polar form of the agent’s position x t .
The target is a vector in R N p , half comprised of “distance" units and half comprised of “direction" units.
Let A ∈ R 0 .
5 N p × 1 , b ∈ R 0 .
5 N p have entries sampled i.i
d. from Uniform ( − 1 , 1) ; the distance cells have activites:
[Equation]
Let µ ∈ [ − π, π ] N p / 2 have entries sampled i.i.d.
uniformly at random.
The direction cells have entries given by von-Mises-like bumps:
[Equation]
• Gaussian: A vector in R N p whose entries are given by:
[Equation]
• Difference of Gaussians: A vector in R N p whose entries are given by: exp (cid:16)
[Equation]
x t
[Equation]
i
[Equation]
(cid:17)
[Equation]
exp (cid:16)
[Equation]
I
[Equation]
x
[Equation]
2 (cid:17) • Difference of Softmaxes: A vector in R N p whose entries are given by: Softmax (cid:16) −2 σ 2 E
|| x
t − p
i || 2 (cid:17) − Softmax (cid:16) − 1 2 σ
I || x
t − p
i || 2 (cid:17) • Softmax of Differences: A vector in R N p whose entries are given by: Softmax (cid:16)
[Equation]
[Equation]
σ 2 E || x t
[Equation]
i
[Equation] [Equation]
[Equation]
σ 2 I
[Equation] [Equation]
B Grid Scores and Grid Cell Thresholds
What qualifies as a grid cell?
The most commonly used method of quantifying grid cells is via the “grid score", which functions by binning neural activity into rate maps using spatial position, applying an adaptive smoother, then taking a circular sample of the autocorrelation centered on the central peak and comparing it to rotated versions of the same circular sample.
The 60 ◦ grid score is specifically given by:
[Equation]
We used the grid scorer implementation used by [3] (https://github.com/deepmind/gridcells/blob/master/scores.py), [51] (https://github.com/ganguli-lab/grid-patternformation/blob/master/scores.py) and [41].
What score is sufficient to qualify as a grid score?
Experimentalists have used thresholds of 0.3 [50] and 0.349 [10] on biological neurons, whereas computationalists have used 0.3 [41] and 0.37 [3, 51] on artificial neurons.
We found that for artificial neurons, these thresholds are far too low (Fig.
ANN units with grid scores > 0 . 4 , and even as high as 1 . 3 , often look nothing like grid cells.
This is because the grid score looks for 60 ◦ rotational symmetry, and while grid cells are indeed symmetric, so are many other rate maps.
Private conversations with the authors of [3, 51, 41] showed everyone was in agreement that grid scores are a metric in need of improvement.
After internal disagreement, we compromised at a grid score threshold of 0.8.
C Number of Bins for Computing Rate Maps
The first step in computing grid scores is determining the number of bins to use to compute rate maps.
However, establishing the number of bins used by previous approaches proved baffling difficult.
The original experimental work used 5 cm by 5 cm bins [25].
Since the square arena used in these experiments is 2.2 m by 2.2 m (same as [3, 51, 41], the number of bins should be 44 x 44.
However, we found discrepancies in previous approaches’ text and code.
[3]’s text claims to use 32 x 32 bins of 6.875 cm x 6.875 cm (“Spatial (ratemaps) and directional activity maps were calculated for individual units as follows.
Each point in the trajectory was assigned to a specific spatial and directional bin according to its location and the direction in which it faced.
Spatial bins were defined as a 32 × 32 square grid spanning each environment and directional bins as 20 equal width intervals.”), but their code 2 used 20 x 20 bins of 11 cm x 11 cm.
[51] claimed to use 2 cm x 2 cm bins (“"Grid score was evaluated as in [3]].
A spatial ratemap was computed for each neuron by binning the agent’s position into 2cm x 2cm bins, and computing the average firing rate within each bin.”)
but their code 3 similarly used 20 x 20 bins.
[41] claimed to use 5 cm x 5 cm bins (“Nayebi: "We bin the positions in each environment using 5 cm bins, following prior work [Hardcastle et al., 2017, Butler et al., 2019, Low et al., 2020].
Thus, the 100cm 2 environment used 400 (20 × 20) bins, the 150cm 2 environment used 900 (30 × 30) bins, and the 400cm 1D track used
[Figure]
[Figure]
dominant method to identify grid cells, but we found it performs extremely poorly at
80 bins.”)
but their code similarly used 20 x 20 bins.
The code suggests that [41] used the grid scorer of [51], who in turn used the grid scorer of [3].
Consequently, we tested what effect the number of bins has on the distribution of grid scores.
We found that the number of bins appears to have little to no effect (Fig. 9), so we chose to use 44 xbins since this yields bins of size 5 cm x 5 cm.
D Place cell autocorrelation
In this section, we will derive the form of the place cell correlation function, centered at ⃗µ .
When the spatial tuning curve is a difference-of-Gaussians, the correlation function is *also* a Difference-ofGaussians, albeit with different parameters.
Consider the spatial tuning curve:
[Equation]
So the correlation between place cells centered at ⃗µ 1 and ⃗µ 2 with r = ⃗µ 1 − ⃗µ 2 is given by
C µ
[Equation]
µ
[Equation]
Simplifying the above expression, using the identity: (cid:82) dx N ( x ; µ f , σ f ) N ( r − x ; µ f , σ f ) =
N ( r ; µ f + µ g , (cid:113) σ 2 f + σ 2 g ) , we get:
[Equation]
method : g r i d metric : goal : minimize name : pos_decoding_err parameters :
Ng : values : −
Np : values : −a c t i v a t
i o n : values : − r e l u − tanh − sigmoid − l i n e a r b a t c h _
s i z e : values : −bin_side_in_m : values : − 0.
box_height_in_m : values : − 2.
box_width_in_m : values : − 2.
i n i t i a l i z e r : values :
− g l o r o t _ u n i f o r m − glorot_normal − o r t
h o g o n a l i s _ p e r i o d i c : values : − f a l s e l e a r n i n g _ r a t e : values : − 0.
n_epochs : values : −n_grad_steps_per_epoch : values : −n _ p l a c e _ f i e l d s _ p e r _ c e l l : values : −o p t i m i z e r : values : − sgd − adam − rmsprop p l a c e _ c e l l _ r f : values : −p l a c e _ f i e l d _ l o s s : values : − mse p l a c e _ f i e l d _ n o r m a l i z a t i o n : values : − none p l a c e _
f i e l d _ v a l u e s : values : − c a r t
e s i a n readout_dropout : values : −− 0.
r e c u r r e n t _
d r o p o u t : values : −− 0.
rnn_type : values : − RNN − LSTM − UGRNN − GRU seed : values : −−−sequence_length : values : −s u r r o u n d _ s c a l e : values : −weight_decay : values : −− 0.
E.2 Cartesian (Low Dimensional, Random) method : random metric : goal : minimize name : pos_decoding_err parameters : a c t i v a t
i
o
n : values : [ ’ relu ’ , ’ tanh ’ , ’ sigmoid ’ , ’ l i n e a r ’ , ] b a t c h
_ s i z e : values : [30 , 60 , 90 , 120 , 150 , 180] bin_side_in_m : values : [ 0 . 0 5 ] box_height_in_m : values : [ 2 . 2 ] box_width_in_m : values : [ 2 . 2 ] i n i t i a l i z e r : values : [ ’ glorot_uniform ’ , ’ glorot_normal ’ , ’ orthogonal ’ , ] i s _ p e r i
o
d i c : values : [ False ] l e a r n i n g _ r a t e : values : [ 0 .
0 5 , 0.001 , 0.0005 , 0.0001] n_epochs : values : [1 , 4 , 8 , 12 , 16] n_grad_steps_per_epoch : values : [10000] n _ p l a c e _ f
i
e
l d s _ p e r _ c e l l : values : [ 1 ]
Ng : values : [1024]
Np : values : [ 2 ] o p t i m i z e r : values : [ ’adam ’ , ’ rmsprop ’ , ] p l a c e _ f i e l d _ l o s s : values : [ ’mse ’ , ] p l a c e _ f i e l d _ v a l u e s : values : [ ’ c a r t e s i a n ’ , ] p l a c e _ f i e l d _ n o r m a l i z a t
i o n : values : [ ’ none ’ , ] p l a c e _ c e l l _ r f : values : [ 0.
] readout_dropout : values : [ 0 . , 0.05 , 0.1 , 0.2 , 0.5 ] r e c u r r e n t _ d r o p o u t : values : [ 0 . , 0.05 , 0.1 , 0.2 , 0.5 ] rnn_type : values : [ ’RNN’ , ’LSTM’ , ’UGRNN’ , ’GRU’ , ] seed : values : [ 0 , 1 , 2 ] sequence_length : values : [20 , 25 , 30 , 35 , 40] s u r r
o
u n d _ s c a l e : values : [ 1 . ]
weight_decay : values : [ 0 . , 0.0001 , 0.0005 , 0.001 , 0.005 , 0.01 ]
E.3 Cartesian (High Dimensional) method : g r i d metric : goal : minimize name : pos_decoding_err parameters :
Ng : values : −
Np : values : −a c t i v a t
i o n : values : − r e l u − tanh − sigmoid − l i n e a r b a t c h _
s i z e : values : −bin_side_in_m : values : − 0.
box_height_in_m : values : − 2.
box_width_in_m : values : − 2.
i n i t i a l i z e r : values :
− g l o r o t _ u n i f o r m − glorot_normal − o r t
h o g o n a l i s _ p e r i o d i c : values : − f a l s e l e a r n i n g _ r a t e : values : − 0.
n_epochs : values : −n_grad_steps_per_epoch : values : −n _ p l a c e _ f i e l d s _ p e r _ c e l l : values : −o p t i m i z e r : values :
− adam p l a c e _ c e l l _ r f : values : −p l a c e _ f i e l d _ l o s s : values : − mse p l a c e _ f i e l d _ n o r m a l i z a t i o n : values : − none p l a c e _
f i e l d _ v a l u e s : values : − h
i g h _
d i m _ c a r t
e s i a n readout_dropout : values : −− 0.
r e c u r r e n t _
d r o p o u t : values : −− 0.
rnn_type : values : − RNN − LSTM − UGRNN − GRU seed : values : −−−sequence_length : values : −s u r r o u n d _ s c a l e : values : −weight_decay : values : −− 0.
E.4 Cartesian (High Dimensional, Random) method : random metric : goal : minimize name : pos_decoding_err parameters : a c t i v a t
i
o
n : values : [ ’ relu ’ , ’ tanh ’ , ’ sigmoid ’ , ’ l i n e a r ’ , ] b a t c h
_ s i z e : values : [30 , 60 , 90 , 120 , 150 , 180] bin_side_in_m : values : [ 0 . 0 5 ] box_height_in_m : values : [ 2 . 2 ] box_width_in_m : values : [ 2 . 2 ] i n i t i a l i z e r : values : [ ’ glorot_uniform ’ , ’ glorot_normal ’ , ’ orthogonal ’ , ] i s _ p e r i
o
d i c : values : [ False ] l e a r n i n g _ r a t e : values : [ 0 .
0 5 , 0.001 , 0.0005 , 0.0001] n_epochs : values : [1 , 4 , 8 , 12 , 16] n_grad_steps_per_epoch : values : [1000] n _ p l a c e _ f i e l d s _ p e r _
c
e l l : values : [ 1 ]
Ng : values : [1024]
Np : values : [128 , 256 , 512]
o p t i m i z e r : values : [ ’adam ’ , ’ rmsprop ’ , ] p l a c e _ f i e l d _ l o s s : values : [ ’mse ’ , ] p l a c e _ f i e l d _ v a l u e s : values : [ ’ high_dim_cartesian ’ ]
p l a c e _ f i e l d _ n o r m a l i z a t
i o n : values : [ ’ none ’ , ] p l a c e _ c e l l _ r f : values : [ 0.0 , ] r e c u r r e n t _ d r o p o u t : values : [ 0 . , 0.05 , 0.1 , 0.2 , 0.
] readout_dropout : values : [ 0 . , 0.05 , 0.1 , 0.2 , 0.5 ] rnn_type : values : [ ’RNN’ , ’LSTM’ , ’UGRNN’ , ’GRU’ , ] seed : values : [ 0 , 1 , 2 ] sequence_length : values : [20 , 25 , 30 , 35 , 40] s u r r
o
u n d _ s c a l e : values : [ 0.
] weight_decay : values : [ 0 . , 0.0001 , 0.0005 , 0.001 , 0.005 , 0.
E.5 Polar (High Dimensional) method : g r i d metric : goal : minimize name : pos_decoding_err parameters :
Ng : values : −
Np : values : −a c t i v a t
i o n : values : − r e l u − tanh − l i n e a r − sigmoid b a t c h _ s i z e : values : −bin_side_in_m : values : − 0.
box_height_in_m : values : − 2.
box_width_in_m : values : − 2.
i n i t i a l i z e r : values :
− g l o r o t _ u n i f o r m − glorot_normal − o r t
h o g o n a l i s _ p e r i o d i c : values : − f a l s e l e a r n i n g _ r a t e : values : − 0.
n_epochs : values : −n_grad_steps_per_epoch : values : −n _ p l a c e _ f i e l d s _ p e r _ c e l l : values : −o p t i m i z e r : values : − adam p l a c e _ c e l l _ r f : values : −p l a c e _ f i e l d _ l o s s : values : − mse p l a c e _ f i e l d _ n o r m a l i z a t i o n : values : − none p l a c e _
f i e l d _ v a l u e s : values : − high_dim_polar readout_dropout : values : −− 0.
r e c u r r e n t _
d r o p o u t : values : −− 0.
rnn_type : values : − RNN − LSTM − UGRNN − GRU seed : values : −−−sequence_length : values : −s u r r o u n d _ s c a l e : values : −weight_decay : values : −− 0.
E.6 Polar (High Dimensional, Random) method : random metric : goal : minimize name : pos_decoding_err parameters : a c t i v a t
i
o
n : values : [ ’ relu ’ , ’ tanh ’ , ’ l i n e a r ’ ,
’ sigmoid ’ , ] b a t c h _ s i z e : values : [30 , 60 , 90 , 120 , 150 , 180] bin_side_in_m : values : [ 0 . 0 5 ] box_height_in_m : values : [ 2 . 2 ] box_width_in_m : values : [ 2 . 2 ] i n i t i a l i z e r : values : [ ’ glorot_uniform ’ , ’ glorot_normal ’ , ’ orthogonal ’ , ] i s _ p e r i
o
d i c : values : [ False ] l e a r n i n g _ r a t e : values : [ 0 .
0 5 , 0.001 , 0.0005 , 0.0001] n_epochs : values : [1 , 4 , 8 , 12 , 16] n_grad_steps_per_epoch : values : [5000] n _ p l a c e _ f i e l d s _ p e r _
c
e l l : values : [ 1 ]
Ng : values : [1024]
Np : values : [128 , 256 , 512]
o p t i m i z e r : values : [ ’adam ’ , ’ rmsprop ’ , ] p l a c e _ f i e l d _ l o s s : values : [ ’mse ’ , ] p l a c e _ f i e l d _ v a l u e s : values : [ ’ high_dim_polar ’ , ] p l a c e _ f i e l d _ n o r m a l i z a t i o n : values : [ ’ none ’ , ] p l a c e _ c e l l _ r f : values : [ 0.
] readout_dropout : values : [ 0 . , 0.05 , 0.1 , 0.2 , 0.5 ] r e c u r r e n t _ d r o p o u t : values : [ 0 . , 0.05 , 0.1 , 0.2 , 0.5 ] rnn_type : values : [ ’RNN’ , ’LSTM’ ,
’UGRNN’ , ’GRU’ , ] seed : values : [ 0 , 1 , 2 ] sequence_length : values : [20 , 25 , 30 , 35 , 40] s u r r
o
u n d _ s c a l e : values : [ 0 . ]
weight_decay : values : [ 0 . , 0.0001 , 0.0005 , 0.001 , 0.005 , 0.01 ]
E.7 Gaussian Place Cells method : g r i d metric : goal : minimize name : pos_decoding_err parameters :
Ng : values : −
Np : values : −a c t i v a t
i o n : values : − l i n e a r − r e l u − tanh − sigmoid b a t c h _ s i z e : values : −bin_side_in_m : values : − 0.
box_height_in_m : values : − 2.
box_width_in_m : values : − 2.
i n i t i a l i z e r : values :
− g l o r o t _ u n i f
o r m i s _ p e r i
o
d i c : values : − f a l s e l e a r n i n g _ r a t e : values : − 0.
n_epochs : values : −n_grad_steps_per_epoch : values : −n _ p l a c e _ f i e l d s _ p e r _ c e l l : values : −o p t i m i z e r : values : − adam p l a c e _ c e l l _ r f : values : − 0.
− 0.
− 0. − 0.
− 0. − 0.
− 0. − 0.
p l a c e _
f
i e l d _ l o s s : values : − c r o s s e n t r o p y p
l a c e _
f i e l d _ n o r m a l i z a t
i o n : values : − global p
l a c e _
f i e l d _ v a l u e s : values : − ga u
ss i an readout_dropout : values : −− 0.
r e c u r r e n t _
d r o p o u t : values : −− 0.
rnn_type : values : − RNN − LSTM − UGRNN − GRU seed : values : −−sequence_length : values : −s u r r o u n d
s c a l e : values : −weight_decay : values : − 0.
E.8 Gaussian Place Cells (Random) method : random metric : goal : minimize name : pos_decoding_err parameters : a c t i v a t
i o n : values : [ ’ l i n e a r ’ , ’ relu ’ , ’ tanh ’ , ’ sigmoid ’ , ] b a t c h _
s i z e : values : [30 , 60 , 90 , 120 , 150 , 180] bin_side_in_m : values : [ 0 . 0 5 ] box_height_in_m : values : [ 2 . 2 ] box_width_in_m : values : [ 2 . 2 ] i n i t i a l i z e r : values : [ ’ glorot_uniform ’ , ’ glorot_normal ’ , ’ orthogonal ’ , ] i s _ p e r i o d i c : values : [ False ] l e a r n i n g _ r a t e : values : [ 0 . 0 0 5 , 0.001 , 0.0005 , 0.0001] n_epochs : values : [1 , 4 , 8 , 12 , 16] n_grad_steps_per_epoch : values : [10000] n _ p l a c e _ f
i
e
l d s _ p e r _ c e l l : values : [ 1.0 , ]
Ng : values : [1024]
Np : values : [128 , 256 , 512]
o p t i m i z e r : values : [ ’adam ’ , ’ rmsprop ’ ]
p l a c e _ f i e l d _ l o s s : values : [ ’ crossentropy ’ , ] p l a c e _ f i e l d _ v a l u e s : values : [ ’ gaussian ’ , ] p l a c e _ f i e l d _ n o r m a l i z a t
i o n : values : [ ’ global ’ , ] p l a c e _ c e l l _ r f : values : [ 0.08 , 0.10 , 0.12 ,
readout_dropout : values : [ 0 . , 0.05 , 0.1 , 0.2 , 0.
] r e c u r r e n t _ d r o p o u t : values : [ 0 . , 0.05 , 0.1 , 0.2 , 0.
] rnn_type : values : [ ’RNN’ , ’LSTM’ , ’UGRNN’ , ’GRU’ , ] seed : values : [ 0 , 1 , 2] sequence_length : values : [20 , 25 , 30 , 35 , 40] s u r r
o
u n d _ s c a l e : values : [ 1 . ]
weight_decay : values : [ 0 . , 0.0001 , 0.0005 , 0.001 , 0.005 , 0.
E.9 Difference-of-Gaussians Place Cells method : g r i d metric : goal : minimize name : pos_decoding_err parameters :
Ng : values : −
Np : values : −a c t i v a t
i o n : values : − r e l u b a t c h _ s i z e : values : −bin_side_in_m : values : − 0.
box_height_in_m : values : − 2.
box_width_in_m : values : − 2.
i n i t i a l i z e r : values :
− g l o r o t _ u n i f
o r m i s _ p e r i
o
d i c : values : − f a l s e l e a r n i n g _ r a t e : values : − 0.
n_epochs : values : −n_grad_steps_per_epoch : values : −n _ p l a c e _ f i e l d s _ p e r _ c e l l : values : −o p t i m i z e r : values : − adam p l a c e _ c e l l _ r f : values : − 0.
− 0.
− 0. − 0.
− 0. − 0.
− 0.
p l a c e _
f
i e l d _ l o s s : values : − c r o s s e n t r o p y p
l a c e _
f i e l d _ n o r m a l i z a t
i o n : values : − global p
l a c e _
f i e l d _ v a l u e s : values : − t r u e _ d
i f f e r e n c e _ o f _ g a u s s i a n s readout_dropout : values : −− 0.
r e c u r r e n t _
d r o p o u t : values : −− 0.
rnn_type : values : − RNN − LSTM − UGRNN − GRU seed : values : −−−sequence_length : values : − s u r r
o
u n d _ s c a l e : values : − 1.
−− 2.
−−−−weight_decay : values : − 0.
E.10 Difference-of-Gaussians Place Cells (Random) method : random metric : goal : minimize name : pos_decoding_err parameters : a c t i v a t
i
o
n : values : [ ’ l i n e a r ’ , ’ relu ’ , ’ tanh ’ , ’ sigmoid ’ , ] b a t c h
_ s i z e : values : [30 , 60 , 90 , 120 , 150 , 180] bin_side_in_m : values : [ 0 . 0 5 ] box_height_in_m : values : [ 2 . 2 ] box_width_in_m : values : [ 2 . 2 ] i n i t i a l i z e r : values : [ ’ glorot_uniform ’ , ’ glorot_normal ’ , ’ orthogonal ’ , ] i s _ p e r i
o
d i c : values : [ False ] l e a r n i n g _ r a t e : values : [ 0 .
0 5 , 0.001 , 0.0005 , 0.0001] n_epochs : values : [1 , 4 , 8 , 12 , 16] n_grad_steps_per_epoch : values : [10000] n _ p l a c e _ f
i
e
l d s _ p e r _ c e l l : values : [ 1 ]
Ng : values : [1024]
Np : values : [128 , 256 , 512]
o p t i m i z e r : values : [ ’adam ’ , ’ rmsprop ’
] p l a c e _ f i e l d _ l o s s : values : [ ’ crossentropy ’ , ] p l a c e _ f i e l d _ v a l u e s : values : [ ’ t r u e _ d i f f e r e n c e _ o f _ g a u s s i a n s ’ ]
p l a c e _ f i e l d _ n o r m a l i z a t
i o n : values : [ ’ global ’ , ] p l a c e _ c e l l _ r f : values : [ 0.08 , 0.10 , 0.12 , 0.14 , 0.16 , 0.20 , 0.24 , 0.28 , 0.32 , 0.36 , 0.40 , ] r e c u r r e n t _
d r o p o u t : values : [ 0 . , 0.05 , 0.1 , 0.2 , 0.5 ] readout_dropout : values : [ 0 . , 0.05 , 0.1 , 0.2 , 0.5 ] rnn_type : values : [ ’RNN’ , ’LSTM’ , ’UGRNN’ , ’GRU’ , ] seed : values : [ 0 , 1 , 2 ] sequence_length : values : [20 , 25 , 30 , 35 , 40] s u r r
o
u n d _ s c a l e : values : [ 1.5 , 2 . , 2.5 , 3 . , 3.5 , 4 . , 4.5 , 5 . , 5.5 , 6 . , ]
weight_decay : values : [ 0 . , 0.0001 , 0.0005 , 0.001 , 0.005 , 0.01 ] method : g r i d metric : goal : minimize name : pos_decoding_err parameters :
Ng : values : −
Np : values : −a c t i v a t
i o n : values : − r e l u − tanh b
a t c h _ s i z e : values : −bin_side_in_m : values : − 0.
box_height_in_m : values : − 2.
box_width_in_m : values : − 2.
i n i t i a l i z e r : values :
− g l o r o t _ u n i f
o r m i s _ p e r i
o
d i c : values : − f a l s e l e a r n i n g _ r a t e : values : − 0.
n_epochs : values : −n_grad_steps_per_epoch : values : −n _ p l a c e _ f i e l d s _ p e r _ c e l l : values : −o p t i m i z e r : values : − adam p l a c e _ c e l l _ r f : values : − 0.
− 0.
− 0. − 0.
− 0. − 0.
− 0. − 0.
− 0. − 0.
− 0. − 0.
− 0. − 0.
− 0. − 0.
p l a c e _
f
i e l d _ l o s s : values : − c r o s s e n t r o p y p
l a c e _
f i e l d _ n o r m a l i z a t
i o n : values : − global p
l a c e _
f i e l d _ v a l u e s : values : − d i f f e r e n c e _ o f _
g a u s s i a n s readout_dropout : values : −− 0.
r e c u r r e n t _
d r o p o u t : values : −− 0.
rnn_type : values : − RNN − LSTM − UGRNN − GRU seed : values : −−−sequence_length : values : −s u r r o u n d _ s c a l e : values : − 1.
−− 2.
−−weight_decay : values : − 0.
E.12 Difference-of-Softmaxes Place Cells (Random) method : random metric : goal : minimize name : pos_decoding_err parameters : a c t i v a t
i o n : values : [ ’ l i n e a r ’ , ’ relu ’ , ’ tanh ’ , ’ sigmoid ’ , ] b a t c h _
s i z e : values : [30 , 60 , 90 , 120 , 150 , 180] bin_side_in_m : values : [ 0 . 0 5 ] box_height_in_m : values : [ 2 . 2 ] box_width_in_m : values : [ 2 . 2 ] i n i t i a l i z e r : values : [ ’ glorot_uniform ’ , ’ glorot_normal ’ , ’ orthogonal ’ , ] i s _ p e r i o d i c : values : [ False ] l e a r n i n g _ r a t e : values : [ 0 . 0 0 5 , 0.001 , 0.0005 , 0.0001] n_epochs : values : [20] n_grad_steps_per_epoch : values : [10000] n _ p l a c e _ f
i
e
l d s _ p e r _ c e l l : values : [ 1.0 , ]
Ng : values : [1024]
Np : values : [128 , 256 , 512]
o p t i m i z e r : values : [ ’adam ’ , ’ rmsprop ’ , ] p l a c e _ f i e l d _ l o s s : values : [ ’ crossentropy ’ , ] p l a c e _ f i e l d _ v a l u e s : values : [ ’ d i f f e r e n c e _ o f _ g a u s s i a n s ’ , ] p l a c e _
f
i e l d _ n o r m a l i z a t
i o n : values : [ ’ global ’ , ] p l a c e _ c e l l _ r f : values : [ 0.08 , 0.10 , 0.12 , 0.14 ,
0.16 , 0.20 , 0.24 , 0.28 , 0.32 , 0.36 , 0.40 , 0.44 , 0.48 , ] readout_dropout :
values : [ 0 . , 0.05 , 0.1 , 0.2 , 0 . 5 ] r e c u r r e n t _ d r o p o u t : values : [ 0 . , 0.05 , 0.1 , 0.2 , 0 . 5 ] rnn_type : values : [ ’RNN’ , ’LSTM’ , ’UGRNN’ , ’GRU’ , ] seed : values : [ 0 , 1 , 2 ] sequence_length : values : [20 , 25 , 30 , 35 , 40] s u r r
o
u n d _ s c a l e : values : [ 1.5 , 2 . , 2.5 , 3.0 , 3.5 , 4.0 , 4.5 , 5.0 , 5.5 , 6.0 , ]
weight_decay : values : [ 0 . , 0.0001 , 0.0005 , 0.001 , 0.005 , 0.01 ]
E.13 Softmax-of-Differences Place Cells method : g r i d metric : goal : minimize name : pos_decoding_err parameters :
Ng : values : −
Np : values : −a c t i v a t
i o n : values : − r e l u b a t c h _ s i z e : values :
−bin_side_in_m : values : − 0.
box_height_in_m : values : − 2.
box_width_in_m : values : − 2.
i n i t i a l i z e r : values :
− g l o r o t _ u n i f
o r m i s _ p e r i
o
d i c : values : − f a l s e l e a r n i n g _ r a t e : values : − 0.
n_epochs : values : −n_grad_steps_per_epoch : values : −n _ p l a c e _ f i e l d s _ p e r _ c e l l : values : −o p t i m i z e r : values : − adam p l a c e _ c e l l _ r f : values : − 0.
− 0.
− 0. − 0.
− 0. − 0.
p l a c e _
f
i e l d _ l o s s : values : − c r o s s e n t r o p y p
l a c e _
f i e l d _ n o r m a l i z a t
i o n : values : − global p
l a c e _
f i e l d _ v a l u e s : values : − s o f t m a x _ o f _ d i f f e r e n c e s readout_dropout : values : −r e c u r r e n t _ d r o p o u t : values : −rnn_type : values : − RNN − LSTM − UGRNN seed : values : −−−sequence_length : values : −s u r r o u n d _ s c a l e : values : − 1.
−− 2.
−weight_decay : values : − 0.
E.14 Multiple Scales and Multiple Fields Difference-of-Softmaxes Place Cells method : g r i d metric : goal : minimize name : pos_decoding_err parameters :
Ng : values : −
Np : values : −a c t i v a t
i o n : values : − r e l u b a t c h _ s i z e : values : −bin_side_in_m : values : − 0.
box_height_in_m : values : − 2.
box_width_in_m : values : − 2.
i n i t i a l i z e r : values :
− g l o r o t _ u n i f
o r m i s _ p e r i
o
d i c : values : − f a l s e l e a r n i n g _ r a t e : values : − 0.
n_epochs : values : − n_grad_steps_per_epoch : values : −n _ p l a c e _ f i e l d s _ p e r _ c e l l : values : − Poisson ( 2.0 ) − Poisson ( 3.0 )
o p t i m i
z
e r : values : − adam p l a c e _ c e l l _ r f : values : − 0.
− Uniform ( 0.06 , 0.24 ) − Uniform ( 0.06 , 1.0 ) p l a c e _ f i e l d _ l o s s : values : − c r o s s e n t r o p y p
l a c e _
f i e l d _ n o r m a l i z a t
i o n : values : − global p
l a c e _
f i e l d _ v a l u e s : values : − d i f f e r e n c e _ o f _
g a u s s i a n s readout_dropout : values : −r e c u r r e n t _ d r o p o u t : values : −rnn_type : values : − RNN − UGRNN seed : values : −−−sequence_length : values : −s u r r o u n d _ s c a l e : values : −− Uniform ( 1.50 , 2.50 ) − Uniform ( 1.25 , 4.50 )
weight_decay : values : − 0.
E.15 Nayebi et al.
2021 [41] Replication method : g r i d metric : goal : minimize name : pos_decoding_err parameters :
Ng : values : −
Np : values : −a c t i v a t
i o n : values : − r e l u b a t c h _ s i z e : values : −bin_side_in_m : values : − 0.
box_height_in_m : values : − 2.
box_width_in_m : values : − 2.
i n i t i a l i z e r : values :
− g l o r o t _ u n i f
o r m i s _ p e r i
o
d i c : values : − f a l s e l e a r n i n g _ r a t e : values : − 0.
n_epochs : values : −n_grad_steps_per_epoch : values : −n _ p l a c e _ f i e l d s _ p e r _ c e l l : values : −o p t i m i z e r : values : − adam p l a c e _ c e l l _ r f : values : − 0.
p l a c e _
f
i e l d _ l o s s : values : − c r o s s e n t r o p y p
l a c e _
f i e l d _ n o r m a l i z a t
i o n : values : − global p
l a c e _
f i e l d _ v a l u e s : values : − d i f f e r e n c e _ o f _
g a u s s i a n s readout_dropout : values : −r e c u r r e n t _ d r o p o u t : values : − rnn_type : values : − RNN − LSTM − UGRNN − GRU − SRNN seed : values : −−−−−sequence_length : values : −s u r r o u n d _ s c a l e : values : −weight_decay : values : − 0.