Neural Circuit Architectural Priors for Quadruped Locomotion

## Abstract

Abstract Learning-based approaches to quadruped locomotion commonly adopt generic policy architectures like fully connected MLPs. As such architectures contain few inductive biases, it is common in practice to incorporate priors in the form of rewards, training curricula, imitation data, or trajectory generators. In nature, animals are born with priors in the form of their nervous system’s architecture, which has been shaped by evolution to confer innate ability and efficient learning. For instance, a horse can walk within hours of birth and can quickly improve with practice. Such architectural priors can also be useful in ANN architectures for AI. In this work, we explore the advantages of a biologically inspired ANN architecture for quadruped locomotion based on neural circuits in the limbs and spinal cord of mammals. Our architecture achieves good initial performance and comparable final performance to MLPs, while using less data and orders of magnitude fewer parameters. Our architecture also exhibits better generalization to task variations, even admitting deployment on a physical robot without standard sim-to-real methods. This work shows that neural circuits can provide valuable architectural priors for locomotion and encourages future work in other sensorimotor skills.

## 1 Introduction

Learning-based approaches to quadruped locomotion commonly adopt generic policy architectures like fully connected multilayered perceptrons (MLPs) (Rudin et al., ; Smith et al., ; Agarwal et al., ).
As such architectures contain few inductive biases, they must rely on training to develop desired behaviors. Simple reward functions often do not lead to naturalistic or robust behavior (Heess et al., ). Therefore, it is common in practice to incorporate priors in the form of rewards (Rudin et al., ), training curricula (Agarwal et al., ; Rudin et al., ), imitation data (Bin Peng et al., ; Merel et al., ), or trajectory generators (Schaal, ; Iscen et al., ).

In nature, animals are born with priors in the form of their nervous system’s architecture, which has been shaped by evolution to confer innate ability and efficient learning (Zador, ; Cisek, ). For instance, a horse can walk within hours of birth and can quickly improve with practice, and humans have strong inductive biases for perceiving and interacting with the world (Lake et al., ). These inductive biases are a reflection of highly structured neural circuit connectivity (Luo, ), which combines innate and learning mechanisms in stark contrast to generic ANN architectures.

Can such architectural priors also be useful in ANN architectures for AI? Bhattasali et al. () investigated this by introducing Neural Circuit Architectural Priors (NCAP). Using a case study of the nematode C. elegans, the proposed Swimmer NCAP translated neural circuits for swimming into an ANN architecture controlling a simulated agent from an AI benchmark (Tassa et al., ). Swimmer NCAP achieved good performance, data efficiency, and parameter efficiency compared to MLPs, and its modularity facilitated interpretation and transfer to new body designs. As such, Swimmer NCAP demonstrated several possible advantages of biologically inspired architectural priors for AI.

However, it remained unknown whether the approach could scale to more complex animals and tasks. C. elegans has a nervous system of only 302 neurons and highly stereotyped connectivity, and its connectome has long been mapped (White et al., ). In contrast, mammalian nervous systems have millions or billions of neurons (Herculano-Houzel et al., ; ) with more variable connectivity and no mapped connectome, so it was not obvious how such circuits could inspire AI.

In this work, we introduce Quadruped NCAP, a biologically inspired ANN architecture for quadruped locomotion based on neural circuits in the limbs and spinal cord of mammals. Our key insights for scaling up the NCAP approach are: modeling at the level of genetically defined neural populations (Danner et al., ; Ausborn et al., ; Kim et al., ) rather than at the level of single neurons, leveraging machine learning to compensate for gaps in detailed circuit knowledge, and introducing methodological innovations to improve the architecture’s expressivity and trainability (Section 2). Together, these insights enable the architecture to successfully control quadruped locomotion, which is a much harder task than planar swimming due to its higher dimensionality and inherent instability.

We test the value of our architectural prior by comparing to an architecture without priors: the MLP, which is commonly used in robotics. Quadruped NCAP achieves good initial (untrained) performance and comparable final (asymptotic) performance to MLPs, while using less data and orders of magnitude fewer parameters. Our architecture also exhibits better generalization to task variations, even admitting deployment on a physical robot without standard domain randomization methods that are often needed for sim-to-real generalization. This work shows that neural circuits can provide valuable architectural priors for locomotion in more complex animals and encourages future work in yet more complex sensorimotor skills.

The key contributions of this work are:

- 1.
First neural circuit model for quadrupedal robot locomotion. We design an architecture that scales up NCAP to quadruped locomotion. While many related works in locomotion have been inspired by biology (Section 2), to the best of our knowledge this work is the first to use genetically defined neural circuits to control locomotion in a standard quadruped robot.
- 2.
Extensive evaluation in simulation. We extensively evaluate NCAP in terms of performance, data efficiency, parameter efficiency, and generalization to terrain and body variations. NCAP learns more naturalistic gaits, with up to millions of fewer timesteps and orders of magnitude fewer parameters than MLP, while being more robust to unseen conditions.
- 3.
Deployment on the physical robot. We deploy NCAP to the physical robot to test its generalization across a large sim-to-real domain gap. While MLP falls immediately, NCAP walks successfully.

Our open-source code and videos are available at: [https://ncap-quadruped.github.io/](https://ncap-quadruped.github.io/)

## 2 Related Work

Our work builds on an extensive literature in neuroscience, robotics, and artificial neural networks. For conciseness, we highlight the most relevant ones to our work:

##### Central Pattern Generators

Central pattern generators (CPGs) are neural circuits that produce rhythmic activity in the absence of rhythmic inputs, and they underlie many movements including chewing, breathing, and locomotion. Roboticists have developed CPG-like controllers for a variety of tasks, and these controllers come in diverse forms (Ijspeert, ; Yu et al., ). For example, the desired movement can be directly engineered using trajectory generators (for instance, swing/stance trajectories) that are adjusted by a higher-level controller (Iscen et al., ). Alternatively, a policy can adopt an action space of controllable abstract oscillators to flexibly modulate (Bellegarda & Ijspeert, ; Shafiee et al., ). In this work, we take a biologically constrained approach that instantiates a CPG using a network of neurons, some of which have intrinsic bursting dynamics.

##### Neuromechanical Models

Neuromechanical models are used in computational neuroscience to develop insights about the interactions between the musckuloskeletal system and the nervous system (Ausborn et al., ; Markin et al., ). Recently, several neuromechanical models have been developed for the rodent (Merel et al., ; Tata Ramalingasetty et al., ) and the fly (Lobato-Rios et al., ; Wang-Chen et al., ), which will enable new understanding about how animals perform movement. In this work, we build upon insights gleaned from neuromechanical models, but our goal is not to control a realistic musckuloskeletal simulation. Rather, we aim to translate insights from biology to AI and robotics, which leads us to model at a higher level of abstraction.

##### Architectural Priors

Architectural priors incorporate structure into an ANN to improve performance and efficiency. For example, convolutional neural networks inspired by the visual system incorporate translation invariance
over images (Lindsay, ). In locomotion, various kinds of architectural prior have been explored, including priors on task and body symmetries (Mittal et al., ; Ding & Gan, ), spring-loaded inverted pendulum dynamics (Ordonez-Apraez et al., ), and hierarchy (Heess et al., ; ). In this work, we explore priors based on genetically defined neural circuits, similar to connnectome-constrained networks explored in the vision literature (Lappalainen et al., ). Our prior is encoded through sparse and structured connectivity, weight sign constraints, weight initializations, bilateral symmetry, and intrinsic neural dynamics.

##### Swimmer NCAP

In this work, we build on Swimmer NCAP (Bhattasali et al., ) by scaling it to more complex settings. The animals we study are more complex: mammals have much larger and less understood nervous systems than nematodes. The AI tasks we tackle are also much harder: the Quadruped is a higher-dimensional inherently unstable body, while the Swimmer is a lower-dimensional inherently stable (planar) body. We also evaluate on a physical robot, in contrast to previous work in simulation only. Thus, our work addresses problems that are especially relevant for AI. Scaling to more complex settings requires novel methodological innovations: (1) We adopt a continuous-time formulation of ANNs, in contrast to the discrete-time Swimmer. (2) We build a recurrent architecture in the Rhythm Generation (RG) module, in contrast to the feedforward Swimmer. (3) We develop a closed-loop Oscillator unit that admits period modulation, phase shifts, and entrainment, in contrast to the open-loop Oscillator unit in Swimmer that does not respond to input signals. (4) We model circuits at the level of neural populations, rather than at the level of single neurons. (5) We enable the architecture to learn unknown connections in the Afferent Feedback (AF) and Pattern Formation (PF) modules by leaving certain connectivity and signs unconstrained, in contrast to the Swimmer which fully constrained connectivity and signs. Together, these novel insights and methods can help the community advance biologically inspired architectural priors.

## 3 Methods

We translate neuroscientific models of quadruped locomotion circuits into an ANN architecture for controlling a robot.
In Section 3.1, we review key background about the neuroscience of locomotion.
In Section 3.2, we describe the computational units that are building blocks in our Quadruped NCAP architecture.
In Section 3.3, we describe the connectivity of NCAP and its interface with the robot.

### 3.1 Biological Locomotion

Figure: Figure 1: Biological Locomotion. A, Quadruped mammals share a homologous organization of their musculoskeletal systems and neural circuits. Surprisingly, neural circuits in the limbs and spinal cord are sufficient to produce locomotion, while higher brain regions are important to initiate and regulate locomotion. B, Neural circuits for rhythm generation (RG) and brainstem command (BC), adapted from Danner et al. (). Each limb is controlled by flexor (F) and extensor (E) half-centers. Between limbs, half-centers communicate through connections that promote synchonization or alternation. Brainstem command signals modulate the half-centers and connection activations. C, Neural circuits for pattern formation (PF) and afferent feedback (AF), adapted from Kim et al. (). Within limbs, interneurons and motorneurons convert half-center states into specific muscle commands, while sensory feedback modulates the circuit at multiple levels.
Refer to caption: x1.png

Quadrupeds locomote by rhythmically flexing and extending their limbs in a coordinated gait to propel the body forward.
They control their velocity by producing various gaits (such as walk, trot, gallop, and bound), and they adapt to different conditions using sensory information.
Quadruped mammals (including mice, cats, dogs, and horses) exhibit considerable differences in appearance, but comparative anatomical studies have revealed a remarkable homology in body structure and neural circuitry between them, which makes sense given their shared evolutionary heritage (Grillner & El Manira, ). Neuroscience research across many animal systems has shed light on how locomotion is achieved through the complex interaction between the musculoskeletal system and neural circuits in the limbs, spinal cord, and higher brain regions (Grillner & El Manira, ). Surprisingly, neural circuits in the limbs and spinal cord are sufficient to produce locomotion, while higher brain regions are important to initiate and regulate locomotion (Rybak et al., ). Classic studies strikingly demonstrated evidence of such organization using decerebrate animals, in which most of the brain was severed from the spinal cord, yet the animal could still walk and even transition between gaits when tugged along a treadmill (Whelan, ). Recent studies have leveraged advances in experimental tools like molecular genetics to precisely map and manipulate locomotor circuits with cell-type specificity (Kiehn, ; Ausborn et al., ).

We summarize below a well-supported neuroscientific model of locomotor circuits (Figure 1), which is based on data from cats and transgenic mice, and which adopts the abstraction of genetically defined neural populations with rate-coded activity. For details, please refer to the referenced works.

##### Rhythm Generation

The RG neural circuit within the spinal cord coordinates limbs to produce gait rhythms (Figure 1B). Each limb is controlled by a half-center microcircuit consisting of a flexor center with intrinsically bursting neurons and an extensor center with tonic firing neurons. The paired centers inhibit each other, leading to oscillating flexion and extension in each limb. The half-centers for the four limbs communicate through “cross” connections (cervical/lumbar commissural interneurons), “side” connections (homolateral long propriospinal neurons), and “diagonal” connections (diagonal long propriospinal neurons), thus enabling bilateral and ascending/descending communication. In essence, excitatory connections between half-centers promote synchronization and inhibitory connections promote alternation, so the speed-dependent activation of these various connections change the timing between limbs and therefore the gait. (Danner et al., )

##### Brainstem Command

The BC neural circuit in the brainstem conveys command signals to adjust locomotor speed and gait (Figure 1B). It does so via two pathways: one controlling speed by modulating the intrinsic period of RG oscillators, and one controlling gait by modulating the “cross” and “diagonal” RG connections that promote synchronization or alternation. (Ausborn et al., )

##### Pattern Formation

The PF neural circuit within each limb converts half-center states into muscle activations (Figure 1C). This circuit of interneurons and motorneurons forms a 2-level hierarchy in which flexion and extension signals are expanded in dimensionality to produce precise activation signals for each muscle. (Kim et al., )

##### Afferent Feedback

The AF neural circuit within each limb uses sensory information to modulate RG and PF activity (Figure 1C). Muscle sensors produce length-, velocity-, and force-related signals, and foot sensors detect tactile stimulation. These signals trigger reflexes in PF and advance/delay half-center states in RG to entrain neural activity with musculoskeletal conditions. (Kim et al., )

### 3.2 Architecture Units

Figure: Figure 2: Architecture Units. The architecture uses 2 neuron types, both of which output rate-coded activity and can receive excitatory or inhibitory synaptic input. For each type, we show the circuit schematic symbol (left), key hyperparameters (middle), and an example waveform response to input (right). A, The Basic unit is a typical neuron that activates proportionally in response to input once its internal voltage exceeds a threshold. This unit is used for most neurons in the architecture. B, The Oscillator unit is a special neuron that exhibits intrinsically bursting activity in the absence of inputs. It scales its intrinsic period in response to constant input, and it entrains its phase in response to periodic input. This unit is used for the flexor half-centers in the RG module.
Refer to caption: x2.png

Our NCAP architecture adopts a continuous-time framework for modeling neurons. We find that 2 computational units can capture the cell types in this circuit: a Basic unit and an Oscillator unit (Figure 2). Many neuromechanical modeling works, including Danner et al. (), use biophysical neuron models that incorporate the conductances, reversal potentials, and activation/inactivation dynamics of ion channel currents (for instance, a persistent sodium current for bursting). Such complexity is not needed for AI purposes, so we follow Bhattasali et al. () by simplifying these neurons to create computational units with fewer and more interpretable hyperparameters. We describe below the main properties of these units. For details and equations, please see Section A.1.

##### Basic Unit

This neuron model is standard in computational neuroscience. Rate-coded inputs raise or lower the internal voltage, which is leaky. If the internal voltage rises beyond a threshold, the neuron generates rate-coded output activity according to an activation function.

##### Oscillator Unit

This neuron model abstracts an intrinsically bursting neuron (Danner et al., ). It generates oscillating output activity in the absence of inputs. In response to inputs, it scales its active and quiet phases, and it transitions to a silent mode under strong inhibition and to a tonic mode under strong excitation. These properties enable the unit to shift its oscillation phase to pulse waveforms, and entrain its oscillation phase to periodic waveforms. We provide a detailed derivation and evaluation of this model in a concurrent manuscript (Bhattasali et al., , in submission).

### 3.3 Architecture Structure

Figure: Figure 3: Architecture Structure. A, The Quadruped robot has 4 limbs, each with 3 joints (hip, thigh, calf) and 1 foot pad. The ANN agent receives proprioceptive/pressure observations, and it produces joint position target actions that are converted to actuator torque commands by a low-level PD controller. B, The Quadruped NCAP architecture mirrors mammalian locomotion circuits. The RG module receives brainstem commands $c_{t}$ that set the speed and gait. Each limb has an AF module that uses leg observations $o_{t}$ to modulate RG oscillators, as well as a PF module that converts RG half-center states into leg actions $a_{t}$.
Refer to caption: x3.png

##### Robot Body

We target a standard robotic body in order to investigate the effectiveness of architectural priors in AI settings (Figure 3A). Unlike animals, the robot does not use highly redundant muscles that produce linear force; instead, it uses a single rotational motor per joint that produces torque. Our architecture controlling this body must translate between biological neural circuitry and the artificial agent interface. For the observation space, the agent receives joint positions, velocities, and torques as well as foot contact pressures. For the action space, the agent produces target joint positions, which are converted to actuator torque commands by a low-level PD controller (Section B.1). While this interface is simplified compared to biology, it reasonably approximates how muscles have a net effect of setting a joint’s equilibrium position and stiffness (Shadmehr, ).

##### Rhythm Generation

We adapt the RG circuit from Danner et al. () to use our simplified Basic and Oscillator units. We eliminate redundant connections and introduce new nomenclature for the neuron types. As discovering the RG connections is not an aim of this work, we hand-tune the RG weights to produce the appropriate gait transitions in response to brainstem input (Figure A.3), using the reported connection strengths from Danner et al. () as a starting point. We then freeze the weights during training. For a full diagram of the RG module, please see Section A.2.

##### Brainstem Command

We use a single brainstem command $c_{t}$ to control the RG module, which is task-specific and frozen during training. This enables us to control the gait pattern expressed at a particular speed. If not frozen, the training usually prefers a bound gait, which is fastest and enables the agent to maximize reward even on slow speed tasks. Having an architectural prior thus affords us fine-grained control of the resulting behavior without additional reward/imitation priors.

##### Pattern Formation

We use a linear PF layer to map flexor/extensor half-center outputs to leg actions $a_{t}$. We initialize PF weights with coarse magnitudes and correct signs (producing negative joint positions for flexion and positive joint positions for extension) that are constrained after each update. We share weights among forelimbs and hindlimbs to exploit bilateral symmetry (Figure D.3), and we apply the overparameterization trick (Section A.3) to expand the dimensionality of weights during training and collapse it during testing.

##### Afferent Feedback

We use a linear AF layer to map leg observations $o_{t}$ to flexor/extensor inputs. We normalize observations to the range [$-1,1$], then rectify them into positive and negative components, since firing rates cannot be negative. We initialize certain AF weights with coarse magnitudes to encode the known effects of leg loading and position on half-centers, and we constrain their signs (Figure D.3). We initialize unknown AF weights at zero and leave them unconstrained. We also utilize bilateral sharing and the overparameterization trick.

## 4 Experiments

##### Tasks

We train our architecture on simulated tasks built atop the MuJoCo physics engine (Todorov et al., ) that control the Unitree A1 robot (Section B.1). The tasks are structured as 15-second episodes during which the robot must locomote forwards at a fixed target speed of Walk (0.5 m/s) or Run (1.0 m/s), and across terrains of Flat or Bumpy (Section B.2). The tasks provide at each timestep a reward proportional to the running speed, with maximum reward of 1 at the target speed in the forward direction (Section B.3). This task structure and reward design is based directly on Smith et al. () in order to facilitate comparison to existing work.

##### Baselines

We compare against multilayered perceptrons (MLPs) of 2 hidden layers. By default, we compare to MLP(256,256), which is a reasonably sized architecture commonly used in the AI and robotics literature. Importantly, we choose to baseline against MLPs as they exemplify an architecture without priors, which contrasts with our NCAP architecture with priors, facilitating a clean comparison. Our goal in this work is not to compare how different classes of prior stack up generally, but rather to explore the value of neural circuit-inspired architectural priors in particular. As architectural priors are somewhat orthogonal to other forms of priors (including reward, training curricula, and imitation priors), future work could combinatorially combine our prior with others.

##### Algorithm

We train both NCAP and MLP architectures using evolution strategies to maximize episodic return (Section C.1). Such gradient-free optimization is easiest to use with our NCAP architecture, and it has successfully and popularly been used to train MLPs in continuous control (Salimans et al., ). In preliminary experiments, we compare evolution strategies to standard on-policy and off-policy reinforcement learning algorithms (Section C.2), and we confirm similar performance across algorithms when training MLPs on our tasks (Section D.1).

### 4.1 Performance and Data Efficiency

Figure: Figure 4: Performance and Data Efficiency. A, Performance curves across tasks. Solid lines are mean normalized returns across 10 training seeds, each tested for 5 episodes per epoch. Shaded areas are 95% bootstrapped confidence intervals. Maximum normalized episodic return is 1, and a policy that outputs all zeros achieves 0.5 by standing still. NCAP matches or exceeds the asymptotic performance of MLP, with superior data efficiency. NCAP also demonstrates better initial performance since it is an effective prior. B, Footfall plots across 3 training seeds on the Flat/Walk task. Colored segments encode the foot contact pressures during stance, while blank segments indicate the limb is in swing. NCAP exhibits qualitatively more naturalistic and consistent gaits than MLP, despite their quantitatively similar asymptotic performances.
Refer to caption: x4.png

NCAP successfully learns to locomote across various speeds and terrains (Figure 4A). For representative examples of NCAP’s behavior and neural activity, please see [Videos 1](https://ncap-quadruped.github.io/).

How does NCAP compare to MLP on performance and data efficiency? NCAP achieves comparable asymptotic performance to MLP across tasks (Figure 4A). Moreover, due to its priors, an untrained NCAP achieves significantly better initial performance than an untrained MLP. The performance of NCAP improves with training as the AF and PF weights are refined. In addition, NCAP’s training trajectories are less variable than the MLP’s.

Interestingly, NCAP appears to train more data efficiently than MLP for the harder Bumpy tasks. For instance, on the Bumpy/Run task, NCAP reaches asymptotic performance about 500 epochs (or 8 million timesteps) before MLP. However, NCAP reaches slightly lower asymptotic performance than MLP for the easier Flat tasks. We attribute this to a regularization effect in NCAP, as it is constrained in the solutions it can learn. In contrast, MLP can learn to exploit the simulator for additional performance gains, which is easier to do on Flat than Bumpy tasks.

This is supported by the qualitative performance of NCAP and MLP. Using footfall plots, we examine learned gaits on the Flat/Walk task for different training seeds (Figure 4B, [Videos 2](https://ncap-quadruped.github.io/)). MLP develops a good walking gait on seed 3, a mediocre limping gait on seed 2, and a failed on-the-floor shuffle on seed 1; this behavior is starkly evident in [Videos 2](https://ncap-quadruped.github.io/). Notably, this high variability is occluded in the performance curve (Figure 4A). In contrast, NCAP exhibits more naturalistic and consistent gaits due to its RG prior. Such gaits would require more priors to elicit from MLP (for example, reward or imitation priors).

### 4.2 Parameter Efficiency

Figure: Figure 5: Parameter Efficiency. A, Performance curves across MLP sizes on the Bumpy/Run task. Smaller MLPs achieve lower asymptotic performance and worse data efficiency. Therefore, having fewer parameters is insufficient to account for NCAP’s advantages. B, Parameter count across architectures (log scale). NCAP(Test) has fewer parameters than MLP(4,4), and even NCAP(Train) with the overparameterization trick (Section A.3) has orders of magnitude fewer parameters than MLPs at typical sizes.
Refer to caption: x5.png

Are the performance and data efficiency advantages of NCAP merely due to having fewer parameters? We test MLP with fewer parameters by varying the hidden layer sizes from 4 to 256. Surprisingly, performance and data efficiency degrade significantly (Figure 5A), showing that it is not merely having fewer parameters that is beneficial. Rather, the specific structure of NCAP matters.

It is this structure that enables NCAP to perform well yet require dramatically fewer parameters than MLPs (Figure 5B). During testing, NCAP uses only 92 parameters (Figure D.4), which is 3 orders of magnitude fewer than MLP(256,256) with 79,372 parameters (Figure D.6), and it is fewer than even MLP(4,4). During training, NCAP with the overparameterization trick has 708 parameters (Figure D.5), which is 2 orders of magnitude smaller than MLP(256,256), and it is comparable to MLP(16,16). Notably, many of these MLPs are much smaller than the sizes typically used in practice. Moreover, in settings like actor-critic reinforcement learning that often use similarly sized actor and critic networks as well as moving average copies of those networks, the number of required parameters can quadruple. NCAP’s parameter efficiency could be particularly advantageous for deployment in resource-constrained environments, like a robot’s onboard compute.

### 4.3 Generalization to Terrain and Body Variations

Figure: Figure 6: Generalization to Terrain and Body Variations. A, Performance on unseen terrain and body variations. Architectures are trained in the condition indicated with a vertical dashed line, then tested in altered conditions. The variations included terrain bumpiness (parameterized from 0 to 1; Figure B.1), body mass (in kilograms), or proportional/damping gains of the low-level PD controller. NCAP’s generalization matches, and often exceeds, that of MLP.
Refer to caption: x6.png

How well does NCAP generalize to unseen environments compared to MLP? We evaluate the architectures across a variety of terrain and body variations (Figure 6). In each setting, the architectures are trained in one condition, then tested in altered conditions. Across these variations, NCAP’s generalization matches, and often exceeds, that of MLP. Surprisingly, MLP performance degrades dramatically on Bumpy terrain, despite the differences in bumpiness seeming minor by human standards (Figure B.1). In contrast, NCAP performs more robustly.

### 4.4 Generalization to the Physical Robot

Figure: Figure 7: Generalization to the Physical Robot. Video frames ([Videos 3](https://ncap-quadruped.github.io/)) of a representative deployment trial on the physical robot. NCAP walks successfully despite the large domain gap, while MLP falls immediately due to its erratic and unstable actions.
Refer to caption: x7.png

How well does NCAP generalize to the real world compared to MLP? We deploy the architectures to a physical Unitree A1 quadruped robot after training on the Bumpy/Walk task (Section B.4). We expect the domain gap to be large since we do not perform controller tuning or system identification with the physical robot, the simulated training does not apply aggressive domain randomization (a form of task prior), and the architectures do not have a mechanism for online adaptation.

MLP falls immediately due to its erratic and unstable actions, often launching the robot aggressively into the wall (Figure 7). Despite our best efforts, we cannot elicit a successful walking trial. In contrast, NCAP is remarkably robust to the large domain gap, walking successfully on most trials, though with less smoothness than in simulation (Figure 7). We attribute NCAP’s success to a combination of the RG module maintaining a stable rhythm in the face of sensor noise and the AF module triggering corrective responses in the face of perturbations. Lastly, we deploy an untrained NCAP and observe that it is stable and produces slight walking movements with small foot displacements ([Videos 3](https://ncap-quadruped.github.io/)).

## 5 Discussion

In this work, we introduce Quadruped NCAP, a biologically inspired ANN architecture for quadruped locomotion based on neural circuits in the limbs and spinal cord of mammals. Our architecture achieves good initial performance and comparable final performance to MLPs, while using less data and orders of magnitude fewer parameters. Our architecture also exhibits better generalization to task variations, even admitting deployment on a physical robot without standard sim-to-real methods.

##### Limitations

Our study faces several limitations. First, we rely on a hand-tuned RG module and BC command, which might not be the optimal parameters that a learning-based approach could discover. Second, we neglect musculoskeletal factors in the quadruped action space that could make learning easier or more robust.

##### Future Work

We focus on fixed speed locomotion in this work, but an obvious next step is to enable the RG to transition between gaits in a speed-dependent manner, which may largely involve a higher-level controller that alters brainstem commands for different speeds. Another extension is to add postural adjustment, turning, and righting mechanisms to the architecture based on understanding of the underlying neural circuits. Finally, as architectural priors are somewhat orthogonal to other forms of priors, it may be beneficial to train NCAP with additional reward, task, or imitation priors.

Overall, we believe that this work shows that neural circuits can provide valuable architectural priors for locomotion in more complex animals and encourages future work in yet more complex sensorimotor skills.

#### Acknowledgments

Thanks for insightful discussions to Pavel Tolmachev, Liam McCarty, Anthony Chen, Ulyana Piterbarg, Jeff Cui, Ben Evans, Siddhant Haldar, Noah Amsel, Yann LeCun, Tony Zador, and many others. This work was supported by the Fannie and John Hertz Foundation Fellowship (NXB); NSF award 2339096 (LP); ONR awards N00014-21-1-2758 and N00014-22-1-2773 (LP); and the Packard Fellowship for Science and Engineering (LP).

#### Author Contributions

Conceptualization (NXB; LP, GWL). Investigation (NXB). Software: simulation (NXB), deployment (VP). Supervision (LP, GWL). Visualization (NXB). Writing: original draft (NXB, VP), review and editing (NXB, VP, LP, GWL).

## Appendix A Architecture Details

### A.1 Architecture Units

##### Basic Unit

The Basic unit is a typical rate-coded neuron with continuous dynamics, which integrates weighted input signals to generate a target $x$ for the internal voltage $v$.

$$ $\displaystyle\text{Hyperparameters: }T_{v},B,f$ $\displaystyle x=\text{clip}(B+\sum\nolimits_{i}{w_{i}y_{i}},-1,1)$ $\displaystyle\frac{T_{v}}{4}\frac{dv}{dt}=x-v$ $$

The neuron’s activation function $f$ determines the voltage-firing relationship:

$$ $\displaystyle y=f(v),\quad f=\text{clip}(v,0,1)$ $$

##### Oscillator Unit

The Oscillator unit is a relaxation oscillator with discrete-continuous dynamics on 2 variables: a discrete internal voltage $v\in{-1,+1}$ and a continuous adaptation variable $a\in[0,1]$.

$$ $\displaystyle\text{Hyperparameters: }T_{a},T_{\text{active}},T_{\text{quiet}}, K_{\text{active}},K_{\text{quiet}},V_{\text{tonic}},B,f$ $\displaystyle T^{\prime}_{\text{active}}=\frac{4T_{\text{active}}}{T_{a}}, \quad T^{\prime}_{\text{quiet}}=\frac{4T_{\text{quiet}}}{T_{a}}$ $$

The adaptation thresholds $a^{\text{0, 1}}_{\text{quiet, active}}$ are calculated that determine the min/max values of adaptation $a$ at which the internal voltage $v$ jumps between active ($+1$) and quiet ($-1$) states:

$$ $\displaystyle a_{\text{active}}^{0}$ $\displaystyle=\frac{1-\exp(T^{\prime}_{\text{quiet}})}{1-\exp(T^{\prime}_{ \text{active}}+T^{\prime}_{\text{quiet}})}$ $\displaystyle a_{\text{quiet}}^{0}$ $\displaystyle=a_{\text{active}}^{0}\cdot\exp(T^{\prime}_{\text{active}})$ $\displaystyle a_{\text{active}}^{1}$ $\displaystyle=\frac{1-\exp(T^{\prime}_{\text{quiet}}\cdot K_{\text{quiet}})}{1 -\exp(T^{\prime}_{\text{active}}\cdot K_{\text{active}}+T^{\prime}_{\text{ quiet}}\cdot K_{\text{quiet}})}$ $\displaystyle a_{\text{quiet}}^{1}$ $\displaystyle=a_{\text{active}}^{1}\cdot\exp(T^{\prime}_{\text{active}}\cdot K _{\text{active}})$ $$

Depending on the strength of the input signal at a given time, the quiet-to-active and active-to-quiet adaptation thresholds interpolate between the calculated min/max values. Adaptation $a$ exponentially decays towards 0 when the neuron is active (the neuron depletes the adaptation variable) and towards 1 when quiet (the neuron replenishes the adaptation variable). Voltage $v$ jumps instantaneously to a new state when an adaptation threshold is reached.

$$ $\displaystyle x=\text{clip}(B+\sum\nolimits_{i}{w_{i}y_{i}},-1,1)$ $\displaystyle z=\text{clip}(x,0,1)$ $\displaystyle a_{\text{active}}=\text{interpolate}(z,a_{\text{active}}^{0},a_{ \text{active}}^{1})$ $\displaystyle a_{\text{quiet}}=\text{interpolate}(z,a_{\text{quiet}}^{0},a_{ \text{quiet}}^{1})$ $\displaystyle\frac{T_{a}}{4}\frac{da}{dt}=\left\{\begin{array}[]{lll}0-a&\text {if }v=+1&\text{(active)}\\ 1-a&\text{if }v=-1&\text{(quiet)}\end{array}\right.$ $\displaystyle v^{(t+dt)}:=\left\{\begin{array}[]{lll}-1&\textrm{if }a^{(t)} \leq a_{\text{active}}^{(t)}\text{ and }x^{(t)}\leq V_{\text{tonic}}&\text{( active $\rightarrow$ quiet)}\\ +1&\textrm{if }a^{(t)}\geq a_{\text{quiet}}^{(t)}\text{ and }x^{(t)}\geq 0& \text{(quiet $\rightarrow$ active)}\\ v^{(t)}&\text{otherwise}&\end{array}\right.$ $$

The neuron’s activation function $f$ determines the voltage-adaptation-firing relationship:

$$ $\displaystyle y=f(v,a,x),\quad f=\left\{\begin{array}[]{lll}\text{interpolate} (a,0.5,1.0)&\text{if }v=+1&\text{(active)}\\ 0&\text{if }v=-1&\text{(quiet)}\end{array}\right.$ $$

We provide a detailed derivation and evaluation of this model in a concurrent manuscript (Bhattasali et al., , in submission).

### A.2 Rhythm Generation (RG) Module

The RG circuit diagram can be visualized in full
(Figure A.1) or through a progressive breakdown (Figure A.2). The RG weights are tuned to produce the appropriate gait transitions in response to increasing brainstem command (Figure A.3).

Figure: Figure A.1: Rhythm Generation, Full. Neural circuits for rhythm generation (RG) and brainstem command (BC) at cell-type-specific resolution, adapted from Danner et al. (). For a progressive breakdown, please see Figure A.2.
Refer to caption: x8.png

Figure: Figure A.2: Rhythm Generation, Breakdown. Neural circuits for rhythm generation (RG) and brainstem command (BC) at cell-type-specific resolution, adapted from Danner et al. (). Each limb is controlled by (A) reciprocally inhibiting half-centers consisting of a flexor Oscillator unit and an extensor Basic unit. Between limbs, half-centers communicate through (B) cross, (C) side, and (D) diagonal connections, and they are modulated by (E) brainstem command and afferent feedback.
Refer to caption: x9.png

Figure: Figure A.3: Rhythm Generation, Gait Transitions. Predicted footfall plots from RG extensor half-center state. The rhythm generation circuit transitions between gaits (walk → trot → bound) as the brainstem command increases from 0 to 1. This enables a higher-level controller to modulate the gait for variable speeds.
Refer to caption: x10.png

### A.3 Overparameterization Trick

We discover an important technique to improve the trainability of our architecture, which we call “the overparameterization trick”.

Consider a linear layer ${\bm{y}}={\bm{W}}{\bm{x}}$. During training, the weight matrix ${\bm{W}}$ can be artificially expanded in dimensionality along the row dimension and/or column dimension to produce a larger weight matrix ${\bm{W}}^{\prime}$. The former produces a correspondingly larger output vector ${\bm{y}}^{\prime}$, while the latter necessitates a correspondingly larger input vector ${\bm{x}}^{\prime}$. The larger output ${\bm{y}}^{\prime}$ can be transformed into the original output ${\bm{y}}$ by summing expanded elements. The original input ${\bm{x}}$ can be transformed into the larger input ${\bm{x}}^{\prime}$ by copying and concatenating elements. Thus, the expanded layer maintains the original input and output dimensions, but with a larger weight matrix and new hardcoded expansion and compression operations at the interface. We find empirically that such overparameterization improved learning, presumably due to special dynamics of traversing high-dimensional loss landscapes with our point-based evolutionary strategies algorithm (Section C.1), but better theoretical understanding of this phenomenon is needed.

During testing, the overparameterized weight matrix ${\bm{W}}^{\prime}$ can be collapsed by summing along the expanded rows and/or columns to produce a smaller matrix with the size of the original ${\bm{W}}$. Mathematically, this does not change the computation, as it exploits the linearity of matrix multiplication.

For a simple example, consider the case of 1D inputs and outputs.

If the weight is expanded row-wise:

$$ $y=wx\quad\underset{\textrm{expand}}{\longrightarrow}\quad y=\sum_{\text{rows}} \begin{bmatrix}w^{\prime}_{1}\\ w^{\prime}_{2}\end{bmatrix}x=(w^{\prime}_{1}+w^{\prime}_{2})x\quad\underset{ \textrm{compress}}{\longrightarrow}\quad y=wx$ $$

If the weight is expanded column-wise:

$$ $y=wx\quad\underset{\textrm{expand}}{\longrightarrow}\quad y=\begin{bmatrix}w^{ \prime}_{1}&w^{\prime}_{2}\end{bmatrix}\begin{bmatrix}x\\ x\end{bmatrix}=(w^{\prime}_{1}+w^{\prime}_{2})x\quad\underset{\textrm{compress }}{\longrightarrow}\quad y=wx$ $$

For this work, the technique enables NCAP to leverage the benefits of training with overparameterized networks using an expanded architecture (Figure D.5), which is compressed for testing (Figure D.4).

## Appendix B Environment Details

### B.1 Simulated Robot

We train our architecture on simulated tasks built using DeepMind Composer (Tassa et al., ) atop the MuJoCo physics engine (Todorov et al., ) using a Unitree A1 robot model imported from MuJoCo Menagerie (Zakka et al., ).

The observation and action interfaces with the agent are normalized to [$-1,1$]. The action space is designed with a default standing pose corresponding to actions of 0 and joint limits corresponding to actions of $\pm 1$.

A proportional-derivative (PD) controller is employed to convert the target joint positions generated by the agent ${\bm{q}}_{\text{target}}={\bm{a}}_{t}$ into joint torque commands for the actuators:

$$ ${\bm{\tau}}=k_{p}({\bm{q}}_{\text{target}}-{\bm{q}})-k_{d}\cdot\dot{{\bm{q}}}$ $$

with joint positions ${\bm{q}}$, joint velocities $\dot{{\bm{q}}}$, proportional gain $k_{p}$, and derivative gain $k_{d}$.

The simulation runs with a control timestep of 0.03 seconds and a physics timestep of 0.001 seconds.

### B.2 Task Structure

The tasks are formulated as 15-second episodes. The agent incurs a penalty and the episode resets if the robot falls over or if any part of its base touches the ground. At the start of each episode, the friction coefficient of the foot is randomized. The agent is trained to move at a fixed velocity of Walk (0.5 m/s) or Run (1.0 m/s) over either Flat or Bumpy terrain (Figure B.1).

### B.3 Task Rewards

We adopt the reward function from Smith et al. (), which uses the forward linear velocity in the robot frame $v_{x}$, the target forward velocity $v_{x}^{\text{target}}$, and the angular yaw velocity $\omega_{z}$.

The overall reward combines a forward velocity reward and a rotational penalty. The tolerance function $r_{v}$ encourages the agent to maintain a forward velocity near the target with some allowable deviation, while the rotational penalty reduces unnecessary rotational movements, ensuring stable and forward-directed motion:

$$ $\displaystyle r(s,a)=r_{v}(s,a)-0.1\omega_{z}^{2}$ $\displaystyle r_{v}(s,a)=\left\{\begin{array}[]{ll}1&v_{x}\in[v_{t},2v_{t}]\\ 0&v_{x}\in(-\infty,-v_{t}]\cup[4v_{t},\infty)\\ 1-\frac{|v_{x}-v_{t}|}{2v_{t}}&\text{otherwise}\end{array}\right.$ $$

Figure: Figure B.1: Terrain Bumpiness. The Flat and Bumpy terrains have different frictions. The Bumpy terrain allows bumpiness to be parameterized between 0 and 1.
Refer to caption: x11.png

### B.4 Physical Robot

##### Deployment Setup

The experiments are conducted on the Unitree A1 quadruped robot with 12 degrees of freedom (3 per leg). The robot has sensors for joint positions, joint torques, joint velocities, and foot contact pressures, and it has actuators that produce commanded torques at each joint. The communication between the robot and the control policy is performed through Lightweight Communications and Marshalling (LCM) (Huang et al., ) and a pybind build of unitree_legged_sdk. The control policy is deployed on the robot from a local workstation through a LAN connection, in order to ensure low-latency and high-reliability communication.

##### Experimental Protocol

The deployment process includes an initial calibration phase to verify joint offsets and zero torque sensors, ensuring accurate sensor readings and actuator control. Notably, no system identification is performed with our simulated robot model. Despite substantial efforts to tune the MLP policy, including adjustments to proportional/derivative gains and initial placement, it struggles to generalize effectively to the physical robot. In contrast, our NCAP policy exhibits surprising robustness.

## Appendix C Algorithm Details

### C.1 Evolution Strategies

##### Augmented Random Search (ARS)

ARS is an evolutionary strategies algorithm that spawns offspring networks by randomly perturbing the parent network’s weights, scores offspring according to a fitness function, and selects the next parent by taking a fitness-weighted average of offspring weights. It can be approximately viewed as estimating gradients of the fitness function. (Mania et al., )

**Table 1: Hyperparameters for ES algorithm. Further details in our provided code.**
| Hyperparameter | ARS |
| --- | --- |
| Population size | 256 |
| Mutation scale | 0.1 |
| Number of workers | 32 |

### C.2 Reinforcement Learning

##### Proximal Policy Optimization (PPO)

PPO is an on-policy reinforcement learning algorithm known for its stability. By maintaining a proximity constraint between the new and old policies, it balances exploration and exploitation, making it a reliable choice for continuous control tasks. (Schulman et al., )

##### Distributed Distributional Deep Deterministic Policy Gradient (D4PG)

D4PG is an off-policy reinforcement learning algorithm known for its data efficiency. By incorporating parallel rollouts and a distributional value function, it efficiently reuses gathered experience to learn continuous control tasks. (Barth-Maron et al., )

**Table 2: Hyperparameters for D4PG and PPO algorithms. Further details in the algorithm implementations from Pardo ().**
| Hyperparameter | D4PG | PPO |
| --- | --- | --- |
| Actor network layers | (256, 256) | (64, 64) |
| Actor network activation function | ReLU | Tanh |
| Critic network layers | (256, 256) | (64, 64) |
| Critic network activation function | ReLU | Tanh |
| Observation normalizer | Mean-Std | Mean-Std |

### C.3 Computational Resources

Training is performed on a high-performance computing cluster running the Linux Ubuntu operating system. The ES algorithm is parallelized over 32 cores. The RL algorithms are parallelized over 16 cores as minimal speedups are observed beyond that on our tasks; this kind of nonlinear scaling is consistent with reported performance tests in other work (Salimans et al., ).

## Appendix D Supplemental Experiments

### D.1 Performance and Data Efficiency

Figure: Figure D.1: Performance and Data Efficiency, MLP Architecture, Various Algorithms. erformance curves across various tasks. Solid lines are mean normalized returns across 10 training seeds, each tested for 5 episodes per epoch. Shaded areas are 95% bootstrapped confidence intervals. The $x$-axis is environment steps to ensure a fair data efficiency comparison between algorithms, although the time efficiency between algorithms is significantly different. ES achieves comparable performance to PPO and D4PG on our tasks.
Refer to caption: x12.png

### D.2 Parameter Efficiency

Figure: Figure D.2: Parameter Efficiency, NCAP/MLP Architectures, Various Tasks. Performance curves across MLP sizes on Bumpy tasks. Smaller MLPs achieve lower asymptotic performance and worse data efficiency, which is more extreme in the harder Bumpy/Run task.
Refer to caption: x13.png

### D.3 Interpretability

Figure: Figure D.3: Interpretability, NCAP Architecture, Untrained, Compact. Weights plot of the untrained NCAP. Weight sign is encoded in color, with excitatory (positive) weights as red and inhibitory (negative) weights as blue. Weight magnitude is encoded in circle lightness and diameter. The non-zero elements of NCAP’s weights are initialized with coarse magnitudes and constrained signs.
Refer to caption: x14.png

Figure: Figure D.4: Interpretability, NCAP Architecture, Trained, Compact. Weights plot of the trained NCAP in its compact/testing variant.
Refer to caption: x15.png

Figure: Figure D.5: Interpretability, NCAP Architecture, Trained, Full. Weights plot of the trained NCAP in its overparameterized/training variant.
Refer to caption: x16.png

Figure: Figure D.6: Interpretability, MLP Architecture, Trained, Full. Weights plot of the trained MLP. Such weights are difficult to interpret, as the rows and columns of hidden weights lack fixed meanings, and weight signs can change freely during training.
Refer to caption: extracted/5910595/figures/a4_interpretability_mlp_trained_full.png

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 6
presentation: 3
questions: 1. How was the model trained? It is important but not clearly stated.
2. What is exactly the MLP for? There are many RL methods with MLP. The baseline is too vague.
3. Does the robot use any sensor except the joint sensors? Can it only walk straight? Can it change gaits?
4. What does the Brainsem command refer to? How does this part of the model work? Are there any reference papers for it? Are there any plots or examples for the command?

The score for the paper could either be up or down according to the responses.
soundness: 3
strengths: The model is a firing rate model modelled with differential equations, which suggests the model has internal dynamics. It could be the reason why it is more parameter-efficient than MLP on continuous control tasks.  The experiments are not only conducted on a simulated robot but also on a real robot.
summary: This paper presented a model for learning motion control of a quadruped robot. The model is bioinspired by incorporating a CPG and firing rate neurons. Experiments show the model can control a robot walking on flat ground well and the model has a higher parameter efficiency than typical MLP models.
weaknesses: While this work is interesting, some of the contributions are overstated. The authors should be careful to claim the "First neural circuit model for quadrupedal robot locomotion", and investigate deeper into older papers from 10, 20, or even 30 years ago, there were papers that used complex CPGs to generate gaits for legged robot locomotion. 

Besides, the key contributions 2 and 3 stated on page 2 are not contributions but simply good practices when researching bioinspired models for robots. The texts from lines 124 to 132 read like contributions but need a better summary.

There is no comparison between the model with SOTA RL models.

The model is not presented very well mathematically. The corresponding section should be in the main text but not the appendix.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: 1. While the paper shows successful quadruped deployment, the novelty is questionable as the core neural architecture is heavily based on Swimmer NCAP, with limited theoretical justification for the adaptations made from simple to complex systems.
2. The paper lacks comparisons with other bio-inspired approaches (especially CPG-based methods which are standard in locomotion control).
soundness: 3
strengths: **Originality & Quality**
- First successful translation of mammalian neural circuits to robot control
- Dramatically efficient: uses only 92 parameters vs 79,372 in traditional methods
- Thoroughly tested in both simulation and real world, with open-source code

**Clarity & Significance**
- Clear explanation and visualization of complex biological-to-AI translation
- Major practical impact: simpler system that works better in real world
- Opens new direction for bio-inspired AI, showing that copying nature's designs can make robot control more efficient and effective
summary: This research introduces "Quadruped NCAP," a new way to make four-legged robots walk by copying how animal nervous systems work. Instead of using traditional artificial intelligence that needs lots of training data, this system copies the natural nerve circuits found in animal legs and spinal cords, using only 92 parameters (while traditional methods use nearly 80,000) yet works remarkably well. The system helps robots walk naturally and adapt to different surfaces, demonstrating that copying designs from nature can create better and more efficient robot control systems.
weaknesses: 1. The theoretical contribution of NN structure is weak, lacking formal analysis of why this biological architecture works better than traditional ones.
2. The tasks (basic locomotion) are relatively simple compared to SOTA robotics challenges, making the parameter efficiency less impressive.
3. Unclear how well NCAP generalizes from simple to complex tasks, with limited analysis of the adaptation process.
4. Missing comparisons with other bio-inspired approaches like CPG and SNN.
5. No justification for why the chosen biological components are optimal for robot control versus other possible biological mechanisms.
6. Hand-tuned RG module could be hiding complexity that's just shifted from parameters to manual engineering.
7. Performance evaluation focuses on basic metrics (walking success).
8. No ablation studies showing which biological components are truly necessary for performance gains.
9. Missing analysis of computational cost and real-time performance requirements versus traditional approaches.
10. Limited exploration of how this approach could scale to more complex behaviors beyond basic locomotion.

---

confidence: 3
contribution: 2
initial_rating: 3
presentation: 3
questions: 1. The article mentions manually adjusting the RG module and BC command, but what is the process of adjustment? What role did each module play during the training and deployment process? 
2. The locomotion control of quadruped robots on multiple terrains is already quite mature, why not train models on more complex terrains? Is it because the generalization of the method is limited?
3. The online reinforcement learning algorithm PPO is relatively easy to implement for motion control of robots on flat ground and can be deployed to physical objects, but using only speed tracking rewards cannot train useful PPO algorithms. Although your experiment has proven the value of prior knowledge, what are the performance advantages of your method?Are there any issues with the subjects of the comparative experiment?
soundness: 2
strengths: 1.Inspired by the ability of horses to stand and walk within a few hours of birth, a biologically inspired ANN architecture based on limbs and spinal cord neural circuits provides a novel perspective in the field of quadrupedal locomotion control.
2.Compared to traditional neural network architectures such as MLP, the model parameters of this research method are very small, and the simulation experiment results have achieved similar performance.
3.It has shown generalization performance in different tasks, even in situations that have not been encountered during training, such as different terrains and speeds, this research method can maintain relatively good performance.
summary: This work is inspired by the four limb and spinal nerve circuits involved in mammal, and explores the advantages of ANN architecture in quadrupedal locomotion control. Compared to traditional neural networks such as MLP, neural circuits can provide valuable prior information for locomotion and achieve good performance with minimal data and parameters.
weaknesses: 1.The author mainly introduces the various components of the model in the method section, and the roles played by these components during the training and inference processes are not clearly explained.
2.Normally, using MLP as the neural network and online reinforcement learning algorithm PPO can control quadruped robots to walk on more complex terrains such as stairs. However, this research method was only tested on flat and bump terrains, and did not verify whether quadruped NAVP can achieve motion control of quadruped robots in more complex scenarios.
3. It has been demonstrated in the experiment that the prior knowledge of quadrupled NAVP is valuable. However, the PPO trained solely on speed tracking as a reward signal does not perform well and cannot prove its performance advantage compared to reinforcement learning.

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: How might the model’s learning stability or convergence be affected if RG and Brainstem parameters were learned rather than hand-tuned? Would automatic learning potentially introduce instability or require a specialized training regime?

If parameters were learned for one locomotion task, could they be transferred or fine-tuned for different tasks (e.g., varied speeds, uneven terrain)? How transferable are these parameters across different conditions?
Does the current architecture allow for speed and gait adaptation on the fly, and if not, what modifications would be necessary to support dynamic speed changes in real time?

Would automatically learning these parameters add significant computational overhead, and if so, how could this be mitigated? Are there any techniques that could allow for efficient online learning or adaptation of these parameters?

Could the authors compare Quadruped NCAP with other models that incorporate different types of architectural priors (e.g., symmetry, task-based priors) to assess specific advantages of neural circuit-based priors?
soundness: 3
strengths: Biologically-Informed Structural Priors: Integrates neural circuit patterns, allowing the model to leverage structural priors that support data-efficient learning and adaptability across various terrains.

Comparison with Traditional ANNs: Contrasts NCAP with conventional artificial neural networks like multilayer perceptrons (MLPs), highlighting that NCAP requires fewer parameters and less data, avoiding the need for large datasets and extensive computational resources.

Real-World Testing and Robust Generalization: Evaluates NCAP’s performance in simulations and on a physical robot, demonstrating effective generalization and adaptability without additional domain adaptation.
summary: The paper presents a biologically inspired neural architecture for quadruped locomotion, named Quadruped NCAP, designed to replicate mammalian neural circuits in the limbs and spinal cord. In contrast to traditional artificial neural networks (ANNs) like multilayer perceptrons (MLPs), which are widely used in robotic locomotion but lack inductive biases, Quadruped NCAP incorporates neural architectural priors, allowing it to operate with better data efficiency and computational resource savings. The study demonstrates that this architecture achieves comparable performance to MLPs while requiring fewer parameters and displaying enhanced generalization to varied terrains and task settings.
weaknesses: Hand-Tuned Parameters: The model’s Rhythm Generation (RG) module and Brainstem Command are set manually rather than learned, which could make it harder to adapt to new tasks or find the best settings automatically.

Fixed Speed Limitation: The model currently supports only one set speed, meaning it cannot adjust its walking or running pace, which limits flexibility in different environments.

Limited to Locomotion Tasks: This study only tests NCAP on walking tasks, so it’s unclear how well this approach would work for other movements or types of tasks.

Meta-review: The authors provided a summary of contributions and reviewers' concerns. 
The authors raised concerns about reviewers R3 and R4. It might be more convincing to have another round of reviews with updated reviewers.

As mentioned by the authors, this paper is about a neural circuit model for the neuroscientific study of motor control, target to ICLR’s “applications to neuroscience” track.
The authors presented MuJoCo simulation experiments to control the Unitree A1 robot without neuroscientific experiments.
R3 asked for baselines against SOTA robotics methods, which didn't satisfy the authors with a focus on applications to neuroscience. 
The AC didn't find any neuroscientific experimental results. It would be nice to show some (even very simple) neural recordings and behavior analysis during motor tasks, as a proof for its “applications to neuroscience”.

Decision: Reject