2.1 Input preprocessing and mossy fiber sampling

In the visual tasks of Fashion-MNIST (fMNIST) and CIFAR-10, the input was normalized by dividing each pixel value by 255, the maximum grayscale value. For motor tasks, we applied Min-Max normalization to scale each feature to [0, 1]. Note that unless otherwise specified, all following paragraphs use row vectors.

To model the sparse input-sharing connectivity between MFs and GrCs, we employed an MF sampling scheme. Specifically, a preprocessed d-dimensional input vector is resampled n times with m features sampled in each iteration, reshaping into a matrix . For image datasets of fMNIST and CIFAR-10, we adopted a combined sampling strategy. In addition to random selection of m = 4 unique pixels, we incorporated local receptive-field (RF) sampling using sliding windows. In visual tasks, this combined strategy exhaustively applies to all possible sliding windows for local RF sampling, followed by random sampling to complete the remaining iterations. For non-visual tasks, we implemented a generalized sampling strategy, where each RF is the unique combination of m components from the input vector . Note that the connectivity topology between MFs and GrCs is determined by this sampling process with random initialization and remains fixed thereafter.

2.2 Tensor-based sparse coding in the granular layer

Utilizing localized feedback inhibitions mediated by GoCs, we developed a tensor-based sparse coding scheme defined as follows (Fig 2A, 2B and 2C). A bin is defined as a spatially localized group of GrCs that share identical sampled MF inputs and implement localized WTA through a specifically associated GoC. Consider a system with n bins, each containing l GrCs, yielding a total population of GrCs. The number of MF sampling iterations equals the number of bins, with m-dimensional MF input shared within each bin, producing an input matrix . Let denote random weights from MFs to GrCs across all bins, where each entry is independently and uniformly sampled from , followed by each weight vector of GrC normalized by its Euclidean norm, i.e., . This commonly used weight normalization technique [30] is applied to ensure that GrC activations characterize MF input patterns rather than differences in the Euclidean norm of weight vectors. Let denote the zero-initialized matrix for bias terms of the N GrCs, and correspondingly denote the flattened vector. For any two vectors , we denote their canonical inner product by . The tensor-based integration of the input matrix generates a matrix :

(1)

Download:

• PNG
  larger image
• TIFF
  original image

Fig 2. Scheme of sparse coding in the granular layer and learning principles in the Purkinje layer.

(A) The upstream circuitry in the cerebellum, including excitatory MF inputs and inhibitory feedback inhibition mediated by GoCs to GrCs. (B) Sparse coding diagram of the upstream circuitry, illustrated with 2 independent bins. Yellow nodes indicate the winners in GrCs. (C) Schematic implementation of the tensor-based GrC sparse coding on visual tasks. (D) The downstream circuitry in the cerebellum, including PFs, PCs, CNs, IO, and CFs. Note the inhibitory nature of PC-CN and CN-IO synapses. (E) CF-error-driven supervised learning by integrated instructive LTD and intrinsic LTP, illustrating the distinction between FP and FN errors.

https://doi.org/10.1371/journal.pcbi.1014595.g002

As described in the Introduction, GoCs receive input from GrCs and provide feedback inhibition, thereby silencing the less-activated GrCs and preserving the most activated ones, referred to as the WTA mechanism. In our model, this GoC-mediated WTA process is approximated by the function for winner selection in each bin, where k denotes the number of winners, producing the sparse matrix :

(2)

Finally, the matrix is flattened into a binary vector , referred to as the GrC code. We will elaborate on the coding process with a geometric interpretation in the Results section. Additionally, we developed coordinate-based storage and multiplication algorithms for efficient GrC code processing, as detailed in the S1 Appendix.

2.3 Encoding vector modules in sparse codes

The scaling invariance of the top-k operation follows directly from:

(3)

Applications in motor control, where the input vector modules information is crucial, require minor modifications of the GrC sparse coding framework. An additional constantly-firing MF is introduced in each bin of GrCs, which is characterized by a fixed input value of 1 and the constant connection weights of 1 to all GrCs within the bin, as a simulation of background input activity. The remaining MFs retain the input values of features and random weights to GrCs, followed by the tensor-based sparse coding process as previously described. In detail, each MF vector is augmented to , where the appended 1 represents a constantly-firing MF. Correspondingly, the weight matrix is extended to before normalization, with denoting constant weights of 1 to all GrCs in this bin.

2.4 Activity-dependent bias adjustment

Feedback inhibitory synapses from GoCs to GrCs have been proposed to serve a “fire more, inhibit more” regulatory function that converges the firing rates toward a common value for all GrCs. This effect, which facilitates firing patterns decorrelation and mitigates the dead-neuron problem inherent in sparse coding schemes, can be modeled as an unsupervised adjustment on the bias term of each GrC, referred to as the activity-dependent bias in the literature [28].

In this study, we implemented the unsupervised activity-dependent bias adjustment in batch processing. For a batch of p samples with corresponding GrC codes, the firing rates of all N GrCs are represented in vector :

(4)

where denotes the GrC code of the i-th sample. The GrCs bias term vector is updated by:

(5)

where is the learning rate. represents the expected firing rate of each GrC, given k winners in l GrCs during WTA, as elaborated in the S1 Appendix. Note that the batched calculation of firing rate should be interpreted as a computational readout of rate-coded population activity in the granular layer, rather than a realistic process performed by biological synapses.

2.5 Purkinje-layer linear multi-class classification

We developed a linear multi-class classifier for supervised learning of GrC codes, incorporating cerebellum-inspired constraints and plasticity-motivated update rules as described below (Fig 2D). Note that for simplicity in description, the term CN refers to a functional aggregation of neurons for output, which may represent only a subset of the complete anatomical cerebellar nuclei structure. Consider there are q distinct classes, each corresponding to a processing stream comprising a PC and a CN. The GrC code is first integrated in the PCs before being transmitted to the CNs for final output. The dense parallel fiber connections from GrCs to PCs are represented by a weight matrix , initialized with all entries set to 1. The linear integration in the Purkinje layer is subsequently computed as:

(6)

Given the extensive interneuron connectivity, the final output of CNs is modeled with the one-versus-all operation top-1 that generates the one-hot encoded vector for the predicted integer label :

(7)

(8)

where the negative sign represents the inhibitory nature of PCs.

2.6 Climbing-fiber-driven supervised learning

The output of CNs is transmitted to the IO through inhibitory projection neurons, interestingly introducing an inversion of sign. Subsequently, is used to compare with the ground-truth one-hot encoded label vector and compute the error signal :

(9)

In the scenario of incorrect prediction, the term FN position refers to where , while the term FP position refers to where .

We first adopted the supervised learning process under the classic assumption using CF-error-driven LTD, as detailed in the S1 Appendix. To enable distinction of both FN and FP errors, an extended mechanism, which decreases weights to the FN position and increases weights to the FP position, is proposed with integrated instructive LTD and intrinsic LTP in a rate-based neural framework given the baseline firing rate of CFs, as detailed below (Fig 2E).

Let denote the all-ones vector of dimension q. Consider the CF baseline firing rate is 1 Hz and compute the error signals relative to this baseline:

(10)

The instructive LTD is modeled as decreases in weights when a pre-synaptic GrC activation coincides with a CF error signal:

(11)

where is the learning rate of LTD. We further define the intrinsic LTP as constant increases in weights by pre-synaptic GrC firing activities, independent of error signals:

(12)

where is the learning rate of LTP. Combining two plasticity mechanisms yields the composite learning rule:

(13)

Under the assumption of balanced plasticity where , the learning rule simplifies to:

(14)

Let denote the true and predicted integer labels, respectively. Interestingly, our learning rule is equivalent to the Multi-Class Perceptron algorithm [31], which becomes evident when rewritten in the following update form:

(15)

Interestingly, it could be proven that, given an arbitrary non-zero LTD learning rate , the learning process is independent of the specific value of the LTP learning rate (Theorem 1 in the S1 Appendix). The learning process of our model is governed by the critical updating component , whose preservation is necessary and sufficient for the weights update in Eq. (13). Therefore, setting only constitutes a concise and intuitive formulation, rather than implying a biologically established balance between LTD and LTP learning rates. This theoretical property was verified numerically on the fMNIST task (S1 Fig).

2.7 Fully-connected feedforward neural network

We employed a three-layer, fully connected FNN with a single hidden layer as the control model. The term “multi-layer perceptron” (MLP) is deliberately avoided, as “perceptron” specifically denotes the Multi-Class Perceptron algorithm in our study. The number of hidden units ranged from 500 to 50,000 to incrementally increase the model parameters, in which training was conducted via backpropagation using the Adam optimizer. Note that the FNN was used as a complexity-matched baseline rather than as a state-of-the-art visual classifier, while comparison with deep neural networks is outside the scope of our study for cerebellum-inspired lightweight architecture.

2.8 Datasets and tasks

In our study, all models were implemented and trained using the Flax and JAX libraries in Python on an NVIDIA A100 GPU. To ensure numerical accuracy, unless otherwise specified, we applied 64-bit float/integer in all tasks except for the comparison tasks with execution time reported, where 32-bit float/integer was used to underline the requirement of computation speed in actual applications. Parallelized operators in JAX Just-in-Time (JIT) compilation were implemented for all models whenever feasible.

We first generated a 2-dimensional toy dataset for concept illustrations. We sampled points with coordinates drawn independently and uniformly from , then retained points satisfying . We labeled the set P₀, corresponding to r₁ = 0, r₂ = 0.5, as class 0, and the set P₁, corresponding to r₁ = 1, r₂ = 1.5, as class 1. Let denote the cardinality of set P. For each , we randomly selected the training subset such that equals the nearest integer to , which was designed around 1000, with the remaining points assigned to the test set.

We subsequently evaluated the cerebellum-inspired neural network on visual classification tasks of two benchmark datasets. The first dataset is fMNIST, consisting of 60,000 training and 10,000 test grayscale images of size across 10 clothing categories. The second benchmark dataset is CIFAR-10 with 50,000 training and 10,000 test RGB color images of shape drawn from 10 object categories, providing a more challenging task than fMNIST while maintaining similar image dimensions and identical class cardinality.

We further investigated the performance of the cerebellum-inspired neural network on two motor control tasks. The first is balancing the CartPole system of classic control theory, simulated in the OpenAI Gymnasium environment [32]. The second is controlling the robotic arm to reach the target position in the Reacher, a more challenging system with potential applications, simulated within the Multi-Joint dynamics with Contact (MuJoCo) physics engine [33] with Gymnasium. The training and evaluation framework is presented below.

2.9 Training and evaluation on motor control tasks

3.1 Construction of the cerebellum-inspired neural network

To construct the cerebellum-inspired neural network, we first implemented minimal dataset preprocessing, employing only Min-Max normalization scaling features to the same range while avoiding negative values. Beyond conventional assumptions of random MF-GrC projections, recent connectome studies have identified structured connectivity patterns, including redundant input-sharing and over-representation motifs [16]. Specifically, each GrC receives approximately 4 MF inputs, with localized GrCs exhibiting preferential connections to shared MF sources. Additionally, the localized feedback inhibition provided by GoC suggests a localized form of WTA sparsification [15,22], similar to a recent study that applied top-1 function to grouped neurons [28]. Taken together, we conceptualized each localized group of GrCs as a bin, where all GrCs receive shared MF inputs and feedback inhibition from a dedicated GoC. Mathematically, a bin is represented by a randomly initialized and normalized weight matrix of dimension: input MFs (e.g., 4) bin width (the number of GrCs in each bin), with the top-k operation applied over GrCs. Concatenating bins of sampled MF inputs yields the GrC sparse code in vector form.

To address the dead-neuron problem inherent in sparse coding schemes, we utilized an unsupervised learning process on GrC bias terms that suppress overactive GrCs and reactivate “dead” neurons, which is biologically consistent with the GoC-mediated feedback inhibition properties [24,25]. In our implementation, the sparsity follows the experimental observation from 1% to 10%, ensuring that each GrC activates in only a small fraction of samples after bias adjustments. Our approach effectively mitigates the dead-neuron problem while simultaneously promoting decorrelation among GrC firing patterns, as detailed in the S1 Appendix.

To facilitate multi-class classification in the downstream circuitry, we modeled the population coding in CNs through the top-1 operation to generate one-hot encoded outputs, aligning with single winner selection mediated with abundant interneurons. Additionally, an alternative biological mechanism for one-hot encoding could be achieved by introducing lateral inhibition between PCs [8].

Focusing on the assumption that CFs convey binary error signals, i.e., the presence or absence of complex spikes, we first modeled the supervised learning process in the Purkinje layer with a classic LTD-based weight update rule [34]. However, since LTD operates unidirectionally by decreasing synaptic weights, it could only correct FN errors. To address this limitation, we incorporated intrinsic plasticity at PF-PC synapses in a rate-based design, formally defined as the Purkinje-Nuclei Classifier in the S1 Appendix, which enables corrections of both the FN and FP errors. Additionally, we trained and evaluated an LTD-only variant detailed in the S1 Appendix, with the Purkinje-Nuclei Classifier displaying higher overall and per-class accuracy on the fMNIST task (S2 Fig).

Interestingly, the learning process of our model is equivalent to the Multi-Class Perceptron algorithm, which utilizes (stochastic) gradient descent for weights optimization to minimize the Multi-Class Perceptron Loss. Remarkably, the supervised learning process becomes independent of the learning rate when initializing the weights with all entries set to the same constant (Theorem 3 in the S1 Appendix). This property eliminates the need for tuning the crucial hyperparameter of learning rate, which is particularly advantageous for a simplified, lightweight neural network of supervised learning. For all subsequent tasks, our implementations use , though any positive value would yield equivalent results due to the independence property.

3.2 Geometric interpretations for GrC sparse representations

We elaborated our modeling approach by theoretical insights and mathematical proofs, specifically investigating properties of GrC sparse representations.

Since sampling occurs independently per bin, we simplify the following discussion by focusing on a single bin, where denotes the corresponding preprocessed MF vector. The vector is mapped into via random weights and subsequently binarized into sparse code with operation:

(16)

(17)

Since each entry of is independently and uniformly sampled from and subsequently normalized to column-wise unit module, effectively forms a dictionary composed of l random atoms in . Crucially, the operation exhibits scaling invariance, as the k largest entries remain unchanged for any scaled vector , where . Therefore, our coding scheme selects the k atoms with the highest cosine similarity values relative to the input and assigns them a fixed coefficient of 1.

This binary sparse coding scheme employs the cosine-similarity-based k-nearest neighbors (KNN) representation from a random dictionary. Let denote the k-nearest neighbors of under cosine similarity. When the sparse coding dictionary is randomly selected with sufficiently large cardinality, it will almost certainly contain k symmetric atoms within a predefined proximity to any , which are selected as . Consequently, within a proximity threshold, inputs produce GrC codes with significant overlap, while sufficiently distant inputs generate non-overlapping codes due to disjoint sets of nearest neighbors. This threshold is primarily governed by the sparsity and affected by sampling randomness and the specific positions of the inputs. Therefore, our coding scheme preserves local neighborhood structures while maximizing the average distance between codes for distinct inputs, except when the inputs are sufficiently close.

Interestingly, in neural networks, cosine similarity represents both the simplest and most feasible measure for the proposed encoding scheme. The scaling invariance inherent to both cosine similarity and the operation aligns well with scaling-invariant contexts of natural scenes, especially visual task processing, where visual datasets exhibit inherent scaling invariance as multiplying the input image by a moderate scalar preserves its essential characteristics for classification. For motor control applications, where the observation vectors and represent fundamentally different system states, preserving vector module information becomes crucial. We proposed an approach utilizing cosine similarity calculated in to identify k-nearest neighbors of , as and possess different angular orientations for distinction. For illustration, when m = 2, the k-nearest neighbors form an elliptical region (S3A and S3B Fig).

We further demonstrated the GrC coding and Purkinje-layer learning principle using the following 2-dimensional toy dataset (Fig 3A). This scenario is linearly non-separable in , thus both the single-layer Multi-Class Perceptron and the Softmax Classifier (classic machine learning algorithm detailed in the S1 Appendix), despite incorporating bias terms, performed poorly (S4A Fig). However, the Euclidean-distance-based KNN Classifier achieved 100% test accuracy for various values of k (S4B Fig).

Download:

• PNG
  larger image
• TIFF
  original image

Fig 3. Expanded GrC sparse representation supports local-structure-preserving separation of input patterns.

(A) Visualization of the 2-dimensional toy dataset after Min-Max normalization, with points in the test set twice as large. The purple line denotes the decision hyperplane of the Purkinje-Nuclei Classifier without GrC coding, with a training accuracy of approximately 50%. (B) The Purkinje-Nuclei Classifier achieved 100% accuracy on training and test sets after GrC coding. (C) The distinct firing pattern separation between two groups of GrCs, each representing a class, dramatically simplified the downstream classification.

https://doi.org/10.1371/journal.pcbi.1014595.g003

To demonstrate the efficacy of our method, we implemented a single bin configuration, with 10 winners from a total population of 200 GrCs. To eliminate dead GrCs, the activity-dependent bias adjustment was applied with learning rate 10^-3 and batch size 100 over 20 epochs. The GrC codes were subsequently processed by the Purkinje-Nuclei Classifier for binary classification, achieving 100% accuracy on both training and test sets with batch size 10 after 5 epochs (Fig 3B). Therefore, our coding scheme successfully transformed the input patterns into the GrCs representation, which is separable by an origin-containing hyperplane. Furthermore, the GrC codes enabled 100% test accuracy when classified using the cosine-similarity-based KNN Classifier with various values of k (S4C Fig).

While it is well-established that projections to GrCs transform low-dimensional linearly non-separable inputs into high-dimensional separable representations, our analysis reveals a novel perspective that each GrC code represents an ensemble of k-cardinality sets of cosine-similarity-based k-nearest neighbors, rather than a point in the space with dimensionality equal to the total number of GrCs. Furthermore, by descendingly reordering GrCs according to their firing count differences between class 0 and class 1 training samples, we observed distinct firing pattern separation between two groups of GrCs, confirming that our GrC coding scheme preserves the local neighborhood structures and projects low-dimensional input patterns onto specific groups of components in the GrC coding vector (Fig 3C).

3.3 Performance on visual tasks

To evaluate the performance on the fMNIST dataset, we implemented the cerebellum-inspired neural network with 2500 bins, each containing 20 GrCs with 2 winners selected, yielding a total of 50,000 GrCs. The activity-dependent bias adjustment was applied with the learning rate 10^-3 and batch size 100 for 5 epochs. The analysis of the cosine distance distribution of GrC codes displayed a larger average inter-class distance compared to the inputs (Fig 4A), while preserving the input local neighborhood structures (S5H and S5I Fig), similar to the patterns of previously illustrated 2-dimensional toy scenario. The Purkinje-Nuclei Classifier was subsequently trained with batch size 200 for 30 epochs, achieving a test accuracy of 90.78% (Fig 4B), which improved approximately 10% and 5% over the Multi-Class Perceptron and the Softmax Classifier, respectively, which were applied directly to fMNIST (S5A-D Fig). An ablation study was performed to elucidate the contributions of the receptive-field design, the bin architecture, and the activity-dependent bias adjustment to this performance gain (Table A in S1 Appendix). We further applied the Multi-Class Perceptron with bias, and the Softmax Classifier without and with bias on GrC codes, achieving minute improvements less than 0.5% (S5E, S5F, and S5G Fig), suggesting our approach is sufficiently effective in this task.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 4. Performance of the cerebellum-inspired neural network on visual tasks.

(A) The cosine distance distribution of inter-class paired input samples and GrC codes for the fMNIST training set. (B) The cerebellum-inspired neural network achieved a final test accuracy of 90.78% in a representative trial on the fMNIST task. Note that the cross-entropy loss was calculated with CN values that applied the Softmax function, while the function was applied in training. (C) The test accuracy and the script execution time of the cerebellum-inspired neural network on the fMNIST task. (D) The test accuracy associated with the script execution time of the cerebellum-inspired neural network and the FNN for a range of configurations on the CIFAR-10 task.

https://doi.org/10.1371/journal.pcbi.1014595.g004

Additionally, a gap was observed between the training and the test accuracy, indicating imperfect generalization on the fMNIST task. This suggests that the sparse, high-dimensional GrC representation could effectively classify training samples, while its generalization on the test set requires further investigation. In the literature, the generalization performance depends on dataset complexity, especially the training-set coverage [35,36]. Following this interpretation, additional experiments on the fMNIST task, as detailed in the S1 Appendix, demonstrated that the test accuracy was significantly influenced by the test samples distribution compared with the training set (S6 Fig). The test accuracy also improved gradually as the training-set size increased (S7 Fig). Additionally, the generalization performance was slightly influenced by the downstream classifier. We analyzed a binary classification case to illustrate that the subtle performance gain of the Softmax Classifier might stem from its enhanced generalization capability by enlarging the decision margin (S8 Fig). These results indicate that the generalization performance of the present model on more complex datasets could presumably be improved through more adaptive sparse coding mechanisms or further architectural design of the classifier.

To emphasize the practical application of the cerebellum-inspired neural network, we exploited the properties of binary GrC codes and the learning rate independence theorem to develop efficient GrC code processing algorithms detailed in the S1 Appendix. Our implementation utilized 32-bit integer count matrices to eliminate numerical computation error while maintaining computational speed comparable to JAX-implemented matrix multiplication. We subsequently benchmarked the performance of our model on both fMNIST and CIFAR-10 datasets against a three-layer FNN trained with backpropagation using the Adam optimizer.

For the fMNIST task, we incrementally reduced the number of randomly sampled bins from 1771 to 0 while maintaining all 729 bins of local RF, resulting in total bin configurations of 2500, 2000, 1500, 1000, 729 in our model, with identical training parameters as previously specified. We matched the hidden units of FNN to the number of GrCs, ranging from 50,000 to 14,580, and applied training with learning rate and batch size 1000 for 100 epochs. For each sample in the CIFAR-10 dataset, we implemented GrC coding separately for each RGB channel and concatenated the 3 resulting GrC codes into a single vector with triple length for Purkinje-Nuclei Classifier processing. Each channel employed bin configurations of 3161, 2661, 2161, 1661, 1161, 961, with each bin containing 10 GrCs with 1 winner selected. The activity-dependent bias adjustment was applied with the learning rate 10^-3 and batch size 100 for 5 epochs. Purkinje-Nuclei Classifier was subsequently trained with batch size 1000 for 40 epochs. The FNN was constructed with progressively decreasing hidden units: 50,000, 25,000, 10,000, 5000, 2000, 1000, 500, and was trained with learning rate and batch size 1000 for 100 epochs. Note that for both models and tasks, these selected parameters were based on fine-tuning to achieve rapid training loss convergence. For each parameter configuration, numerical trials were conducted for 5 independent random seeds. During each trial, we recorded both the total Python script execution time and final test accuracy, reporting the mean standard deviation across 5 repetitions as our primary performance metric.

For both fMNIST and CIFAR-10 tasks, our model demonstrated comparable performance to the FNN and achieved computational acceleration with matching numbers of neurons (Figs 4C, 4D, and S9). Two factors primarily contribute to the rapid computation of our model. First, the GrC coding, equivalent to the input-to-hidden-layer transformation, operates as an unsupervised feedforward process. Therefore, our model requires only single Purkinje-layer matrix correction calculations, which are significantly faster than backpropagation through two layers. Second, by leveraging insights from the sparse codes and the gradient descent process, we developed efficient coordinate-based binary sparse GrC code storage and processing algorithms that enable parallel computation of samples, which contributes to the subtle time increase despite the number of GrCs scaled by more than 3 times. Therefore, our implementation maintained higher computational speed than FNN for larger numbers of neurons, achieving over acceleration in the scenario with 50,000 GrCs or hidden units.

3.4 Performance on the CartPole task

We evaluated the performance of the cerebellum-inspired neural network on balancing the CartPole system with physically realistic dynamics simulated in the OpenAI Gymnasium environment (Fig 5A).

Download:

• PNG
  larger image
• TIFF
  original image

Fig 5. Cerebro-cerebellar framework for the cerebellum-inspired neural network on the CartPole task.

(A) Illustrations of the CartPole environment and the cerebro-cerebellar framework. (B) Schematic diagram of the strategy-based trial-and-error for dataset generation and the training scheme. (C) The well-trained model rapidly stabilized the pole angular deviation from non-equilibrium initial states and maintained quasi-periodic subtle fluctuations for maximal achievable 500 timesteps. 10 randomly initialized trajectories were sampled for illustration.

https://doi.org/10.1371/journal.pcbi.1014595.g005

The CartPole environment consists of a cart moving horizontally along a frictionless track, with an unactuated pole attached via a frictionless hinge joint. The observation space incorporates four continuous variables: the cart’s linear displacement x^(t), the cart’s linear velocity , the pole’s angular displacement , and the pole’s angular velocity . The discrete action space A contains binary force actuation: a constant leftward force and a constant rightward force . The control objective is to select an action at each timestep to stabilize the system, with stability criteria imposing two constraints. First, the angular deviation of the pole must remain bounded (). Second, the displacement of the cart must not exceed the track length (|x^(t)| < 2.4). Trial termination occurs upon violation of either constraint. The performance metric is the duration of each trial, with maximal achievable 500 timesteps defining success.

We generated the dataset of observations and actions with the trial-and-error based strategy S defined as follows (Fig 5B). When selecting an action at time t, the agent applies to obtain and , resets to the environment state at time t, then applies to obtain and . For , S first selects if and have different signs while and have same signs. Otherwise, S selects where . In the following text, all random initializations are employed by default methods of the Gymnasium environment. 1000 random seeds were sampled to initiate each trial, in which 200 timesteps of strategy-based trial-and-error were performed, with observation and label of action (0 or 1) recorded at each timestep.

The generated dataset was partitioned into 190,000 training samples, with the remainder allocated to the validation set, followed by the GrC coding process. Each RF comprised 2 components from the 4-dimensional observation vector, generating bins, each populated by 1700 GrCs, resulting in a total of 10,200 GrCs. The top 5% of GrCs in each bin were selected as winners, and the activity-dependent bias adjustment was applied with learning rate 10^-4 and batch size 100 for 10 epochs. Subsequently, the Purkinje-Nuclei Classifier was trained for binary classification using batch size 200 for 200 epochs.

Upon convergence of the training loss with a training accuracy of 100%, we evaluated the model performance in controlling the CartPole system within the Gymnasium environment across trials with random initializations. This evaluation of our model involved real-time continuous interaction directly with the environment, as detailed in the Methods section. The trained model successfully maintained balance for the maximal duration of 500 timesteps in all 100,000 trials without failure. Further analysis of dynamics revealed that the cerebellum-controlled pole rapidly stabilized from non-equilibrium initial states, exhibiting quasi-periodic fluctuations with subtle angular deviation (Fig 5C and S1 Video). Notably, the model was trained on a limited set of 1000 sampled trajectories but was systematically evaluated with randomly initialized, extensive 100,000 trials with sustained robust performance. Therefore, our model efficiently acquired and executed an observation-action mapping after supervised learning in the CartPole balancing task.

3.5 Performance on the Reacher task

We further evaluated the performance of the cerebellum-inspired neural network on the Reacher, a more challenging control system with realistic applications, simulated in the MuJoCo physics engine with Gymnasium (Fig 6B).

Download:

• PNG
  larger image
• TIFF
  original image

Fig 6. Performance of the cerebellum-inspired neural network on the Reacher task.

(A) The trained model achieved a success rate of 99.14% across 100,000 randomly initialized trials, with a median termination time of 0.54 seconds for successful trials. (B) Illustration of the Reacher environment. (C) The snapshots of the well-trained model controlling the Reacher system. (D) Illustration of the trial-and-error based strategy for two consecutive steps in the Reacher.

https://doi.org/10.1371/journal.pcbi.1014595.g006

The Reacher environment involves controlling a two-joint robotic arm fixed at the origin (0, 0). The observation space consists of 10-dimensional continuous vector with dependent components, while the action space comprises 2-dimensional continuous action vector representing the torques applied at each hinge joint. The primary control objective is to minimize the time for the endpoint of the arm, referred to as the fingertip, to reach a randomly positioned target and subsequently stabilize it within a predefined proximity threshold. Note that both fingertip and target positions are randomly initialized at each trial onset, with the target remaining static thereafter.

We generated datasets of observations and actions with the trial-and-error based strategy S defined as follows (Fig 6D). Both Torque₀ and Torque₁ are constrained to discrete values chosen from . The discrete action space comprises all 9 possible combinations of these torques, defined as , with each action state labeled numerically from 0 to 8. Let d^(t) denote the Euclidean distance between the fingertip and the target at time t. When selecting actions at time t with observation , the agent explores all possible action state sequences for two consecutive steps to obtain , resetting to time t after each execution of two-step action state sequence . The strategy S is to select the which minimize . We subsequently sampled 4000 random seeds to initiate each trial, in which 50 timesteps of trial-and-error were performed using S, with the observation and corresponding action label (0–8) recorded at each timestep.

We implemented an analogous training procedure as described previously. The validation set comprised 100 samples, with the remaining samples allocated to the training dataset. For the GrC coding, each RF consisted of 5 components in the 10-dimensional observation vector, resulting in bins, each containing 400 GrCs with the top 5% selected as winners, yielding a total of 100,800 GrCs. The activity-dependent bias adjustment was applied with the learning rate 10^-4 and batch size 100 for 10 epochs. The Purkinje-Nuclei Classifier was subsequently trained with batch size 200 for 800 epochs.

Upon convergence of the training loss, we evaluated the performance of the cerebellum-inspired neural network on the environment across 100,000 randomly initialized trials in real-time continuous interaction with the environment. Each trial spanned a maximum of 150 timesteps, with early termination triggered if d^(t) < 0.02 for 5 consecutive timesteps. Trials failing to satisfy this termination criterion within 150 timesteps were recorded as failures. For successful trials, the termination timestep served as the performance metric, which jointly assessed the speed of convergence to the target position and the steady-state positional maintenance stability. The trained model demonstrated robust performance, achieving a success rate of 99.14% with a median termination time of 27 timesteps for successful trials, which corresponds to 0.54 seconds in simulated environment time (Fig 6A and 6C and S2 Video). These results indicate that our model efficiently learned an observation-action mapping that supported closed-loop control of the Reacher system.