Measuring and Controlling Solution Degeneracy across Task-Trained Recurrent Neural Networks

## Abstract

Abstract Task-trained recurrent neural networks (RNNs) are versatile models of dynamical processes widely used in machine learning and neuroscience.
While RNNs are easily trained to perform a wide range of tasks, the nature and extent of the degeneracy in the resultant solutions (i.e., the variability across trained RNNs) remain poorly understood.
Here, we provide a unified framework for analyzing degeneracy across three levels: behavior, neural dynamics, and weight space.
We analyzed RNNs trained on diverse tasks across machine learning and neuroscience domains, including N-bit flip-flop, sine wave generation, delayed discrimination, and path integration.
Our key finding is that the variability across RNN solutions, quantified on the basis of neural dynamics and trained weights, depends primarily on network capacity and task characteristics such as complexity.
We introduce information-theoretic measures to quantify task complexity and demonstrate that increasing task complexity consistently reduces degeneracy in neural dynamics and generalization behavior while increasing degeneracy in weight space.
These relationships hold across diverse tasks and can be used to control the degeneracy of the solution space of task-trained RNNs.
Furthermore, we provide several strategies to control solution degeneracy, enabling task-trained RNNs to learn more consistent or diverse solutions as needed.
We envision that these insights will lead to more reliable machine learning models and could inspire strategies to better understand and control degeneracy observed in neuroscience experiments.

## 1 Introduction

Recurrent neural networks (RNNs) are widely used across machine learning and computational neuroscience for modeling dynamic processes.
They can be efficiently trained using standard nonconvex optimization techniques and have proven useful for understanding neural dynamics during task performance (Sussillo, ; Rajan et al., ; Barak, ; Mastrogiuseppe & Ostojic, ; Vyas et al., ; Driscoll et al., ).
While it is well-known that in feedforward networks, differences in weight initialization and randomness during training (stochastic gradients, mini-batch sample variability, etc.)
can cause different final solutions, less is known about how such differences manifest when training RNNs
(Das & Fiete, ; Turner & Barak, ; Collins et al., ; Glorot & Bengio, ; Fort et al., ; Goodfellow et al., ; Li et al., ; Jastrzebski et al., ; Chaudhari et al., ; Frankle & Carbin, ; Kornblith et al., ).

Traditionally, the study of task-trained RNNs has often focused on analyzing models trained using a single approach, implicitly assuming that multiple RNNs trained on the same task would converge to similar solutions, even when trained differently or when starting from different initial conditions.
However, recent work has shown that this assumption may not hold universally.
For instance, Maheswaranathan et al. () found that while trained RNNs may share certain topological features, their internal representation geometry can vary widely.
Similarly, Turner et al. () discovered that task-trained networks can develop qualitatively distinct dynamics.

These contrasting findings raise a fundamental question about the degeneracy of task-trained RNN solutions: when do networks trained on the same task converge to similar dynamics and representations, and when do they exhibit substantial degeneracy?
Previous studies offer conflicting perspectives, with some suggesting that task-trained RNNs exhibit dynamics that are universal across instances (Maheswaranathan et al., ), while others emphasize the degeneracy across individual solutions (Turner et al., ; Galgali et al., ; Gholamrezaei & Whishaw, ; Gao et al., ; Mehrer et al., ).

In this paper, we reconcile these differing views by providing a unified framework for analyzing degeneracy at three levels: behavior, neural dynamics, and weight space.
We hypothesize that the variation in solutions of trained RNNs is influenced by task under-specification.
In other words, when constraints do not uniquely or adequately determine the network’s solution to a given task, we observe greater variability across trained networks (D’Amour et al., ). To test this hypothesis, we investigate how different task characteristics, particularly at the level of complexity of the inputs and outputs, affect degeneracy of the solutions found by task-trained RNNs at three levels (across behavioral, neural, and weight space).
We simulated four tasks – N-Bits Flip Flip, Delayed Discrimination, Sine Wave Generation, and Path Integration 1. Our key finding is that as task complexity increases, the solution space becomes more constrained, reducing degeneracy in both behavior and neural dynamics but increasing degeneracy in the underlying network weights.

Our simulations confirm the above hypothesis at the behavioral and neural-dynamical levels: with increasing task complexity, the degeneracy of solutions – measured at the behavioral level by the coefficient of variation of the out-of-distribution performance and at the dynamical level by the Dynamical Similarity Analysis distance
– decreases consistently across all four tasks we tested 3 5 (Ostrow et al., ).
Interestingly, at the weight level, we observe the opposite trend: the degeneracy of solutions increases with task complexity.

After quantifying degeneracy at behavioral, neural, and weight-levels, next we propose practical strategies for controlling the level of degeneracy in task-trained RNNs, including altering task complexity, incorporating auxiliary loss functions, and applying structural constraints during training. These methods provide flexibility for researchers aiming to tailor the training process to their specific needs, whether they are seeking more consistent (Kepple et al., ) or more diverse RNN solutions (Liebana Garcia et al., ; Fascianelli et al., ; Pan-Vazquez et al., ; Kepple et al., ).

### 1.1 Contributions

Our contributions with this paper are as follows:

- •
Information-theoretic quantification of task complexity: We introduce a new framework for assessing task complexity by quantifying the information content in the input and target output time series of a task. This measure effectively captures the extent to which input-output signals constrain neural dynamics. Furthermore, this measure correlates well with the neural-dynamical degeneracy we observed both across different complexity levels within the same task and across different tasks.
- •
Quantifying the degeneracy of solution spaces: We measure degeneracy at the behavioral, dynamical, and weight levels in populations of trained networks across four different tasks of wide applicability to both ML and neuroscience. Our findings reveal that, across all tasks, increased task complexity leads to lower degeneracy at the behavioral and neural dynamical levels, but concomitantly higher degeneracy at the weight level.
- •
Methods for controlling degeneracy: We propose five techniques for controlling degeneracy in task-trained RNNs, including manipulating task complexity, applying specific regularization during training through auxiliary losses, and structural constraints during training. Notably, we demonstrate that both neural dynamical degeneracy and weight degeneracy can be manipulated to change either in the same (“covariant”) or opposite directions (“contravariance”), providing flexibility for researchers to tailor network solutions to their specific needs (Cao & Yamins, ; Kepple et al., ; Fascianelli et al., ; Maheswaranathan et al., ; Durstewitz et al., ; Gilpin, ) .

## 2 Methods

### 2.1 Model Architecture

We used discrete-time nonlinear *vanilla* recurrent neural networks (RNNs), where the update rule is defined as:
$\displaystyle\mathbf{h}_{t}=F(\mathbf{h}_{t-1},\mathbf{x}_{t})=\tanh\left(
\mathbf{W}_{h}\mathbf{h}_{t-1}+\mathbf{W}_{x}\mathbf{x}_{t}+\mathbf{b}\right),$
where $\mathbf{h}_{t}\in\mathbb{R}^{n}$ is the hidden state at time $t$, $\mathbf{x}_{t}\in\mathbb{R}^{m}$ is the input at time $t$, $\mathbf{W}_{h}\in\mathbb{R}^{n\times n}$ is the recurrent weight matrix, $\mathbf{W}_{x}\in\mathbb{R}^{n\times m}$ is the input weight matrix, and $\mathbf{b}\in\mathbb{R}^{n}$ is the bias vector.

A linear readout layer is applied on top of the RNN hidden state to produce the model’s prediction at each time step. The RNNs use Backpropagation Through Time (BPTT) as the learning rule where the RNN is unrolled over time, allowing gradients to be computed for each time step in the sequence (Werbos, ). All networks are trained using supervised learning via the Adam optimizer, with a learning rate specific to each task determined via hyperparameter tuning (a list of all training-related hyperparameters can be found in Appendix A). For each task, we train 50 networks using different initializations, until they achieve near-asymptotic loss on the test set. For the N-Bit Flip-Flop and Path Integration tasks 1, we use RNNs with 64 hidden units and input/output dimensions appropriate to each task’s specific requirements.
For the Delayed Discrimination and Sine Wave Generation tasks 1, we use RNNs with 128 hidden units.

### 2.2 Tasks

Figure: Figure 1: Task suite: We train RNNs on a diverse set of four tasks: N-Bit flip-flop: Networks are trained to remember the last non-zero input for each of the N channels. Delayed Discrimination: Networks compare the magnitude of two temporally separated pulses across N channels. Sine Wave Generation: Networks receive static input indicating frequency and produce sine waves of the specified frequency across each of the N channels. Path Integration: Networks integrate velocity inputs to track position in a bounded arena in 2D or 3D space. Schematic only shows 2D environment.
Refer to caption: extracted/5902981/figures/ICLR-01.png

N-Bit Flip-Flop Task
In this task, RNNs are provided with $N$ independent input channels, each taking discrete values from $\{-1,0,+1\}$, with a fixed probability of switching $p_{switch}$.
The network has $N$ output channels, each of which is required to remember the value of the last nonzero input received on its respective input channel.
We vary the complexity of the task by changing the number of input and/or output channels $N$.

Delayed Discrimination Task
The network is presented with two pulses of varying amplitudes $f_{1},f_{2}\in[2,10]$, separated in time by a variable delay $t\in[5,20]$ time steps.
The network is required to output the sign of the difference between the two amplitudes, i.e., $\operatorname{sign}(f_{2}-f_{1})$.
This task can be extended to have $N$ independent input and output channels, where the network must compare $f_{1}$ and $f_{2}$ within each channel separately.
We vary the complexity of the task by varying the number of independent input and/or output channels $N$.

Sine Wave Generation
RNNs receive a static input indicating a target frequency $f\in[1,30]$ and are required to generate a sine wave of that frequency over time, effectively converting the input $f$ into the output $\sin(2\pi ft)$.
We define $N_{\text{freq}}$ as the number of possible target frequencies presented in the training set, equally spaced within the range $[1,30]$.
This task can involve $N$ independent input and output channels, where each channel outputs a sine wave with the frequency specified by its respective input channel.
We vary the complexity of the task by changing $N_{\text{freq}}$ and $N$, the number of independent input and/or output channels.

Path Integration Task
Each network is initialized at a random initial location within a bounded 2D environment. At each time step, the network receives inputs representing the angular direction $\theta$ and speed $v$, and must integrate this information over time to output the updated $(x,y)$ location. To vary the complexity of the task, we introduce a 3D version of the task, where the network receives inputs $\theta$ (azimuth angle), $\phi$ (elevation angle), and $v$ (speed), and must output the updated $(x,y,z)$ location.
The network effectively performs path integration by accumulating movement vectors based on the input directions and speeds.

## 3 Results

### 3.1 Characterizing tasks complexity and neural dynamics (RNN hidden states)

We quantified the task complexity by calculating the Shannon entropy of its input and target (output) time-series (Shannon, ; Bialek et al., ; Crutchfield & Young, ).
We chose this measure because it directly reflects the amount of information present in the task’s inputs and outputs, which the network must process and represent through its hidden state (Tishby et al., ).
By quantifying the statistical complexity of the input and output time series, we capture the information-processing demand imposed on the network.

Figure: Figure 2: Characterizing tasks and RNN hidden states (neural dynamics): We analyze task complexity and its effects on RNN hidden states using multiple measures: (A) Input complexity, measured as the entropy of the time-averaged input signal. We use the integer in the task name to indicate the number of input-output channels for each task except in “sineF”, where “F” stands for frequency, and the integer indicates the number of frequencies the network learns to produce. (B) Output complexity, measured as the entropy of the time-averaged output signal (C) Our tasks span three quadrants of the Input and Output Complexity space (excluding low input and low output complexity). (D) The number of leading Principal Components (PCs) explaining 95% of the variance, which we use as a measure of the dimensionality of the task, increases consistently across tasks as difficulty increases. (E) RNN hidden state (neural dynamics) trajectories projected onto the leading two PCs for Path Integration and three PCs for the other tasks.
Refer to caption: extracted/5902981/figures/ICLR-02.png

Without loss of generality, given a one-dimensional output time series $(y_{1},y_{2},\dots,y_{T})$, the entropy of this time series is given by:
$\displaystyle H(Y)=-\sum_{k=1}^{n}p(y_{k})\log_{2}p(y_{k}),$
where $n$ is the number of unique values in the time series, and $p(y_{k})$ is the probability of observing the value $y_{k}$ in the time series.

For Sine Wave Generation and Path Integration tasks, the outputs are continuous values rather than discrete ones.
Therefore, we binned the output values into discrete intervals before calculating the entropy.
For task variants with multiple independent channels, we multiplied the single-channel entropy by the number of channels.
Since each channel operates independently and has identical statistical properties, multiplying the single-channel entropy by $N$ provides an accurate measure of the total entropy across all channels. For a training set with $M$ trials, we averaged the entropy across all trials presented in the training set to obtain a representative measure of task complexity:
$\displaystyle H_{\text{task}}=N\times\left(\frac{1}{M}\sum_{i=1}^{M}H(Y^{(i)})
\right).$

Different tasks are characterized by their specific input and output complexity profiles (Figure 2A and 2B).
Within each task, increasing the number of input and output channels consistently increases both the input and output complexities.
We selected our tasks to span three quadrants of the input-output complexity space (Figure 2C):

- •
High-input, high-output complexity: N-Bit Flip-Flop and Path Integration tasks
- •
High-input, low-output complexity: Delayed Discrimination task
- •
Low-input, high-output complexity: Sine Wave Generation task

Among them, the N-Bit Flip-Flop task exhibits the highest input and output complexities among all tasks, suggesting that it imposes the greatest information-processing demands on the networks.

We then provide a link between the task complexity and the dimensionality of the representation demanded by the tasks.
We found that the number of leading Principal Components (PCs) explaining 95% of the variance increases consistently across tasks as difficulty increases, indicating that harder tasks demand higher-dimensional representations and fuller utilization of the networks’ representational capacity (Figure 2D) (Gao et al., ).

Typical solutions found by converged networks across the different tasks are as follows (Figure 2E):
In N-Bit flip-flop tasks, networks learn two fixed points corresponding to the output value of $\{-1,+1\}$ for each channel.
Networks further factorize the fixed points corresponding to different output channels along different orthogonal dimensions.
Specifically , when $N=3$, networks learn $2^{3}=8$ fixed points on the vertices of a 3D cube.
In Delayed Discrimination tasks, networks memorize
the first input
value by storing each input value as a separate fixed point during the delay period, when the inputs to the network are no longer on and working memory is required (Hopfield, ; Sussillo & Barak, ; Driscoll et al., ). In Sine Wave Generation tasks, networks develop limit cycles corresponding to different target frequencies indicated by inputs, and traverse different limit cycles to produce different sine wave outputs at the appropriate frequencies. In 2D Path Integration tasks, without any external input, networks develop 2D maps of their environments using a 2D plane of attractors. Without any inputs, a network’s hidden state (neural dynamics) stabilizes on fixed points corresponding to their current location.

### 3.2 Characterizing the degeneracy of task-trained RNNs

We now quantify the degeneracy of task-trained RNNs at three levels of analysis: (out of distribution) behavior, neural dynamics, and weight space.
We also relate the measured degeneracy back to the task complexity measure introduced in the last section.

#### 3.2.1 Degeneracy in dynamics decreases with task complexity

We use a recently published measure for comparing dynamical systems, called Dynamical Similarity Analysis (DSA) (Ostrow et al., ), to perform pairwise comparisons of the neural dynamics in our task-trained networks.
DSA measures the temporal and topological structure of the system’s dynamics and ignores geometric configurations that alter the spatial representation of system trajectories without changing the underlying dynamics.
It provides a quantitative framework to assess how different networks may arrive at similar or distinct dynamical implementations of a task
(See Appendix C for technical details).

To quantify the relationship between task complexity and dynamical degeneracy, we increased the complexity of the tasks by increasing the number of independent input and output channels.
This choice is grounded in information theory, as an entropy measure of task complexity is additive for statistically independent variables.
We found that within each task, increasing the number of input and output channels consistently reduced the dynamical degeneracy across the converged networks (Figure 3A).
Strikingly, this relationship (“covariant” degeneracy with task complexity) holds across all the tasks we consider (Figure 3C).

Figure: Figure 3: Dynamical degeneracy decreases with increased task complexity: (A) Pairwise Dynamical Similarity Analysis (DSA) scores decrease consistently across all tasks as we increase task complexity, suggesting more similar (less degenerate) dynamical solutions for harder tasks. In Sine Wave Frequency, we change the frequency content of the task and in Sine Wave N, we change the number of input-output channels (N) of the task. (B) 2D embedding of pairwise DSA distances using Multi-Dimensional Scaling (MDS) on the N-bit flip-flop task shows how the spread of solutions decreases as task complexity is increased. Each dot represents a network with a different initialization. (C) Output complexity versus the average dynamical degeneracy on a task shows how higher output complexity correlates with lower dynamical degeneracy both within and across tasks. Within each task, larger marker size and less opacity indicate task variant with higher complexity. Smaller DSA score implies dynamics are more similar.
Refer to caption: extracted/5902981/figures/ICLR-03.png

#### 3.2.2 Degeneracy in weights increases with task complexity

Figure: Figure 4: Degeneracy in weight space (measured using permutation-invariant metrics) increases with increased task complexity: (A) Pairwise distances between weights, measured by the normalized Frobenius norm of the recurrent connectivity matrix , increase consistently with task complexity, across all tasks. (B) Distances from initialized weights, quantified by the Frobenius Norm, also increases with task complexity, indicating greater divergence in weight space for harder tasks. In other words, we observe greater variation/variability across trained individuals (individual differences) at the connectivity level, even with the opposite trend observed at the dynamical and behavioral levels. Each line represents the distance from the initialized weights for a given network.
Refer to caption: extracted/5902981/figures/ICLR-04.png

We quantify degeneracy across task-trained RNNs at the level of post-training weights by using a permutation invariant modification of the Frobenius Norm.
For a pair of RNNs with recurrent weight matrices given by $\mathbf{W}_{1}$ and $\mathbf{W}_{2}$, we define:
$\displaystyle d_{\text{PIF}}(\mathbf{W}_{1},\mathbf{W}_{2})=\min_{\mathbf{P}_{
1},\mathbf{P}_{2}\in\mathcal{P}(n)}\|\mathbf{W}_{1}-\mathbf{P}_{1}\mathbf{W}_{
2}\mathbf{P}_{2}\|_{F}$,
where $\mathcal{P}(n)$ is the set of permutation matrices of size $n\times n$, and $\|\cdot\|_{F}$ denotes the Frobenius norm.
(See Appendix D for additional details)
For comparing networks of different sizes, we normalize the above norm by the number of parameters in the weight matrix. We found that pairwise distances between weight matrices from converged RNNs increases consistently as task complexity increases across all tasks (Figure 4A).

Inspired by research linking statistical mechanics of random Gaussian landscapes to deep learning theory (Bahri et al., ; Fyodorov & Williams, ; Bray & Dean, ), we hypothesized that increasing task complexity while holding the network size constant could make possible solutions ’rarer’ at the level of recurrent weights.
This implies that the optimization process would have to, on average, search for solutions further away from the initial recurrent weights to converge.
We found that the distance between the converged weight matrices and the initialized weight matrices indeed increases consistently with task complexity, and does so across all the tasks (Figure 4B and Table 1). Formally, distance from initial weights is $\|\mathbf{W}_{T}-\mathbf{W}_{0}\|_{F}$,
where $\mathbf{W}_{T}$ is the weight matrix after training and $\mathbf{W}_{0}$ is the initial weight matrix.
We normalize this measure by the number of parameters in the weight matrix across tasks.

#### 3.2.3 Degeneracy in out-of-distribution generalization behaviors decreases with task complexity

Figure: Figure 5: Behavioral degeneracy, in terms of variability of the OOD generalization performance, decreases with increased task complexity: Degeneracy of the out of distribution (OOD) generalization behavior, as measured by coefficient of variation of the OOD performance (mean squared error), decreases consistently with increasing task complexity across all tasks.
Refer to caption: extracted/5902981/figures/OOD_cv.png

Does degeneracy in Out-of-Distribution generalization behaviors change concomitantly with degeneracy in neural dynamics (hidden state) with task complexity?
We hypothesize that lower dynamical degeneracy implies that networks respond to input stimuli with more similar dynamics. Therefore, when these networks are probed with out-of-distribution (OOD) inputs, they should produce more similar outputs, leading to lower dispersion in their OOD performance across networks (i.e., lower degeneracy).
In other words, as task difficulty increases and dynamical degeneracy decreases, the degeneracy in OOD performance should also decrease.

To test this hypothesis, we measured the OOD performance (mean squared error) of converged networks that all achieved near-asymptotic training loss under the following *length generalization* conditions.
For Delayed Discrimination tasks, we doubled the length of the delay period; for all other tasks, we doubled the length of the entire trial.
We then calculated the coefficient of variation (CV) of the OOD performance across networks, defined as $CV=\sigma/\mu$,
where $\sigma$ is the standard deviation of the OOD performance across networks, and $\mu$ is the mean OOD performance.

Our results show that across all tasks, networks with lower dynamical degeneracy indeed exhibited lower CV in their OOD performance 5. This finding supports our hypothesis that increased task complexity, which reduces dynamical degeneracy, also leads to more consistent – less degenerate – OOD generalization behaviors across networks. The prediction this result makes is that when trained on harder tasks, “expert” animals in neuroscience labs or task-trained networks/agents in ML should show less individual variation in generalization performance when tested.

### 3.3 Controlling degeneracy of task-trained RNNs

Figure: Figure 6: Differential control of weight and dynamics degeneracy: Using Delayed Discrimination (DD) tasks as an example, we demonstrate various methods to control the degeneracy of solution spaces found by task-trained RNNs: (A) Adding an auxiliary loss. Adding an additional loss term to calculate the signed difference (not just direction) between the two consecutive inputs adds additional structure to the learned dynamics, resulting in reduced dynamical degeneracy and increased weight degeneracy. (B) Changing network size: By increasing the networks’ size, we decrease the load on their representational capacity, which in turn, results in more degeneracy in their neural dynamics or hidden states. Simultaneously, we see greater degeneracy in their weight space (i.e., the trend in degeneracy is in the same direction for both dynamics and weights). (C) Regularizing weights to be low rank: We see a decrease in both dynamical and weight-space degeneracy with increasing low-rank regularization on the recurrent weights and reduced distance from initialized weights, likely due to smaller-magnitude weight updates. (D) Regularizing weights to be sparse: Similar to above, we see a decrease in both dynamical and weight degeneracy with increasing sparsity of the recurrent weight matrix.
Refer to caption: extracted/5902981/figures/ICLR-05.png

Based on our characterization of task complexity and quantification of degeneracy at multiple levels of analysis, we propose several methods to control degeneracy across task-trained RNNs, making predictions for ML and neuroscience studies:

Increase task complexity:
As discussed in the previous section, increasing task complexity reduces dynamical degeneracy and increases weight degeneracy in a consistent and measurable way in a suite of tasks of broad interest to ML and neuroscience.

Adding auxiliary loss:
We can directly change the degeneracy of the solution spaces found by task-trained RNNs by adding additional terms to the objective/loss function that are consistent with but distinct from the primary task objective.
This introduces additional structure to the learned dynamics, which in turn, decreases dynamical degeneracy and increases weight degeneracy, as networks must satisfy multiple constraints simultaneously.
Figure 6A shows an example implementation of this idea on a Delayed Discrimination task. We demand that the network output $f_{1}-f_{2}$, instead of only $sign(f_{1}-f_{2})$.
By analyzing the RNN’s neural dynamics or hidden state after both input stimuli have been presented, , we find that the additional objective forces the network to learn “line attractors” (Strogatz, )
with the same sign as network without the additional loss, but with variable magnitudes reflecting different values of $f_{1}-f_{2}$ (Figure 7).

Modifying representational load (or network capacity):
Changing the network size (or the number of units in the RNN) affects its representational capacity.
Increasing network size typically leads to increased dynamical degeneracy due to more degrees of freedom.
Simultaneously degeneracy increases across weight space because of more parameters.
(Figure 6 B).

Imposing structural constraints on weight spaces(or regularization of recurrent weight matrices): Applying regularization techniques such as low-rank (nuclear norm) (Figure 6 C) or sparsity (L1) (Figure 6 D) regularization to the recurrent weight matrix generally decreases the degeneracy across neural dynamical and weight spaces simultaneously (Mastrogiuseppe & Ostojic, ; Narang et al., ; Herbert & Ostojic, ).

Figure: Figure 7: RNNs learn more structured dynamics with auxiliary losses: In Delayed Discrimination tasks trained with auxiliary losses (e.g., an auxiliary output $f_{1}-f_{2}$ in addition to main output $sign(f_{1}-f_{2})$), RNNs neural dynamics or hidden states develop more sophisticated representations to track task-variables with 1-D manifolds (right) rather than just point-attractors (left).
Refer to caption: extracted/5902981/figures/ICLR-06.png

These methods provide a toolkit for controlling degeneracy that naturally follows from our earlier analyses.
Importantly, we report that some interventions (increasing task complexity and modifying network capacity) induce an inverse or “contravariant” relationship between weight-space and dynamical degeneracy, while others (structural constraints) tend to affect both dynamical and weight-space degeneracy in the same direction or “covariantly” (Summarized in Table 1).
Overall, the degeneracy of the solution space is primarily controlled by two key factors: the task complexity and the representational capacity of the networks.
Among the manipulations to control degeneracy in RNNs, increasing task complexity and adding auxiliary losses directly alter the task complexity
while representational load and adding structural constraints directly impact the representational capacity of the networks.

## 4 Related work

Our approach extends a previously proposed measures of task complexity (Meister, ), which defined a task as a mapping from states to actions, and quantified task complexity as the entropy of all possible state-action mappings.
Here, we regard tasks as predefined time-series of inputs and outputs rather than in terms of state-action mappings.
By taking into account the temporal dynamics explicitly, we quantify the statistical complexity of the input and output time-series using Shannon entropy.
Meister () focuses on evaluating task-complexity from a learning-theory perspective: specifically, the amount of information an animal needs to acquire a perfect mapping between states and actions.
In contrast, we focus on the representational capacity and the constraints imposed by the processing demands of a task.
Our measure directly captures the amount of information that must be “carried” through the neural dynamics to produce the desired output.
Our measure of task complexity is also consistent with the notion of Neural Task Complexity proposed by Gao et al. (), which provides an upper bound on the dimensionality that neural trajectories can explore during a task.
We have demonstrated that within each type of task, variants with higher output complexity require higher dimensional representations (Figure 2D).

We further show that the output complexity of a task directly shapes the degeneracy of solutions found by RNNs. While previous work speculated that the degree to which neural dynamics are attractor-heavy may influence degeneracy (Turner et al., ), we have quantified the “attractor-ness” of our tasks and found that it alone does not account for the different levels of dynamical degeneracy across tasks (see Appendix B).
Moreover, as we modified the task characteristics
to study its effect on degeneracy, we observed that degeneracy remains invariant under certain transformations of the task, e.g., changing the delay duration in Delayed Discrimination or altering the environment size in Path Integration tasks.
In our framework, these transformations do not affect the output complexity of the task and thus leave the degeneracy unchanged.
In the language of complex systems theory, these factors (e.g., delays) are “sloppy dimensions” of the task with respect to degeneracy.
In contrast, factors that directly modify output complexity (e.g., adding channels, changing network size) are “stiff dimensions” that significantly control and modulate degeneracy of solutions (Gutenkunst et al., ; ; Daniels et al., ; Kepple et al., ).

Our findings are also consistent with the Contravariance Principle from Cao & Yamins (): the harder a task, the more constrained the system that solves it will need to be.
Another recent study by Huh et al. () hypothesizes that AI models seem to be converging on the same representation spaces independent of modality, because more constraints from the massive-scale data make degenerate solutions less likely.
Notably, the above related findings are based on feedforward networks for visual object categorization and Transformer networks for language modeling, respectively. Here, our study demonstrates that these ideas also generalize to recurrent networks/RNNs.

## 5 Discussion

Our paper presents a unified approach to quantifying and controlling the degeneracy of solutions found by task-trained RNNs across behavioral, neural dynamical (or hidden states), and weight-space levels of analysis.
We simulated and analyzed a task suite of broad interest to ML and neuroscience, yielding several novel insights.

First, information content in inputs and outputs of different tasks, which we use to quantify task complexity, emerges as a crucial determinant of degeneracy.
This perspective helps reconcile previously conflicting observations on degeneracy across a range of tasks and measures.
Second, across different tasks, as task complexity increases, we observe a robust inverse relationship between neural dynamical and weight degeneracy.
As a corollary, while harder tasks lead to more consistent neural dynamics across task-trained networks, their underlying recurrent weight matrices are more degenerate/variable.

Third, our study exemplifies several strategies for controlling solution degeneracy, including manipulating task complexity, adding auxiliary loss functions, adjusting network capacity, and structural constraints on recurrent weights 1. These prescriptions will allow researchers to tailor the level of degeneracy of networks to suit specific research questions (e.g., probing individual variability across animals in neuroscience experiments) or application needs (Bouthillier et al., ; Morik, ; Yang et al., ).
Importantly, we observed that certain strategies–increasing task complexity or modifying network capacity—induce an inverse (contravariant) relationship between weight and dynamical degeneracy, while others—imposing structural constraints—tend to affect both types of degeneracy in the same or covariant direction.

While our study is based on artificial neural network models, some of the above strategies could apply to neuroscience experiments, (Howard, ) e.g., introducing an auxiliary sub-task during behavioral shaping of lab animals to learn different tasks may constrain the degeneracy of the solutions learned by the biological brain and manifest in a different representational load than in an animal trained using a “curriculum” without an auxiliary sub-task.
We note that degeneracy is also ubiquitous in other biological systems (Golub et al., ; Prinz et al., ; Edelman & Gally, ); thus, we motivate future theoretical studies based on them.

In summary, our work provides insights into the factors that shape the solution landscape of task-trained RNNs.
The framework we bridges differing perspectives in prior work, reconciling observations of both universality and individuality in trained networks in ML and neuroscience.
Future research could delve deeper into the theoretical underpinnings of the observed relationships in biological and artificial agents, including neural networks, between task complexity, representational capacity, and degeneracy.

## Acknowledgements

This work was supported by the NIH (RF1DA056403), James S. McDonnell Foundation (220020466), Simons Foundation (Pilot Extension-00003332-02), McKnight Endowment Fund, CIFAR Azrieli Global Scholar Program, NSF (2046583), and Harvard Medical School Dean’s Innovation Award. A.H. is supported by the Kempner Graduate Fellowship. We would like to thank Arna Ghosh, Andy Keller, Naomi Saphra, Yu Duan, Hanson Lu, and all members of the Rajan Lab for helpful discussions.

## Appendix A Task and training details

### A.1 N-Bit Flip Flip

| Hyperparameter | Value |
| --- | --- |
| Optimizer | Adam |
| Learning rate | 0.001 |
| Learning rate scheduler | None |
| Max epochs | 300 |
| Steps per epoch | 128 |
| Batch size | 256 |
| Early stopping threshold | 0.0005 |
| Patience | 3 |
| Probability of flip | 0.3 |
| Number of time steps | 100 |

### A.2 Delayed Discrimination

| Hyperparameter | Value |
| --- | --- |
| Optimizer | Adam |
| Learning rate | 0.001 |
| Learning rate scheduler | CosineAnnealingWarmRestarts |
| Max epochs | 500 |
| Steps per epoch | 128 |
| Batch size | 256 |
| Early stopping threshold | 0.05 |
| Patience | 3 |
| Number of time steps | 60 |
| Max delay | 20 |
| Lowest stimulus value | 2 |
| Highest stimulus value | 10 |

### A.3 Sine Wave Generation

| Hyperparameter | Value |
| --- | --- |
| Optimizer | Adam |
| Learning rate | 0.0005 |
| Learning rate scheduler | None |
| Max epochs | 500 |
| Steps per epoch | 128 |
| Batch size | 32 |
| Early stopping threshold | 0.05 |
| Patience | 3 |
| Number of time steps | 100 |
| Lowest frequency | 1 |
| Highest frequency | 30 |

### A.4 Path Integration

| Hyperparameter | Value |
| --- | --- |
| Optimizer | Adam |
| Learning rate | 0.001 |
| Learning rate scheduler | ReduceLROnPlateau |
| Learning rate decay factor | 0.5 |
| Learning rate decay patience | 40 |
| Max epochs | 1000 |
| Steps per epoch | 128 |
| Batch size | 64 |
| Early stopping threshold (2D) | 0.1 |
| Early stopping threshold (3D) | 0.3 |
| Patience | 3 |
| Number of time steps | 100 |
| Lowest frequency | 1 |
| Highest frequency | 30 |

## Appendix B Characterizing the Attractorness of the Tasks

Attractors are associated with stable states in a network’s dynamics. To quantify how attractor-heavy a task is, we measure the speed of change in the RNN’s hidden activities. Specifically, we calculate the average normalized difference between the hidden states at two consecutive time steps. This measure reflects the stability of the network’s internal states over time, where slower changes indicate the presence of attractor-like behavior.

For each trial, given a time series of hidden state activities, we calculate the speed of change in the hidden activities as:

$$ $\Delta h=\frac{\lVert h_{t+1}-h_{t}\rVert}{\frac{1}{T}\sum_{t=1}^{T}\lVert h_{ t}\rVert}$ $$

where $T$ is the total number of time steps in the trial. We then average $\Delta h$ across all trials in the training set to obtain a representative measure of the average speed of change in hidden activations for the task. A low $\Delta h$ indicates that the hidden state is changing slowly over time, suggesting that the network is in or near an attractor state where the hidden activations are relatively stable. Conversely, a high $\Delta h$ indicates more rapid changes in hidden activity, implying less attractor-heavy dynamics.

As shown in Figure A1, tasks like N-Bits Flip-Flop and Path Integration, which have the highest task complexity and lowest dynamical degeneracy, span opposite ends of the ”attractorness” spectrum. Interestingly, Delayed Discrimination, which exhibits the highest dynamical degeneracy, shows an intermediate attractorness score. This suggests that the attractorness score, as measured by the speed of change in hidden activity, does not fully account for the dynamical degeneracy observed in the networks. Therefore, while attractor-like behavior influences network dynamics, it is not the sole factor determining dynamical degeneracy across tasks.

Figure: Figure A1: Normalized speed of change in hidden state activities for each task: (A) Speed of change in hidden state activity ($\Delta h)$for all trials in the training set plotted in violin plot for each task (B) Overlaid histogram of ($\Delta h)$ for all tasks (C) Individual ($\Delta h)$ for each task.
Refer to caption: extracted/5902981/figures/appendix_attractor_0.png

## Appendix C Dynamical Similarity Analysis (DSA)

Briefly, DSA proceeds as follows:
Given two RNNs with hidden states $\mathbf{h}_{1}(t)\in\mathbb{R}^{n}$ and $\mathbf{h}_{2}(t)\in\mathbb{R}^{n}$, we first generate a delay-embedded matrix, $\mathbf{H}_{1}$ and $\mathbf{H}_{2}$, by sampling several hidden-state trajectories from each RNN.
Next, for each delay-embedded matrix, we use Dynamic Mode Decomposition (DMD) (Schmid, ) to extract linear forward operators $\mathbf{A}_{1}$ and $\mathbf{A}_{2}$ of the two systems’ dynamics.
Finally, a Procrustes distance between the two matrices $\mathbf{A}_{1}$ and $\mathbf{A}_{2}$ is used to quantify the dissimilarity between the two dynamical systems and provide an overall DSA score, defined as:
$\displaystyle d_{\text{Procrustes}}(\mathbf{A}_{1},\mathbf{A}_{2})=\min_{
\mathbf{Q}\in O(n)}\|\mathbf{A}_{1}-\mathbf{Q}\mathbf{A}_{2}\mathbf{Q}^{-1}\|_
{F}$
where $\mathbf{Q}$ is a rotation matrix from the orthogonal group $O(n)$ and $\|\cdot\|_{F}$ is the Frobenius norm.
This metric quantifies how dissimilar the dynamics of the two RNNs are after accounting for orthogonal transformations.
We quantify Dynamical Degeneracy across many RNNs as the average pairwise distance between pairs of RNN neural-dynamics/hidden-state trajectories

**Table 2: Hyperparameters for DSA**
| Task | Number of delay | Rank |
| --- | --- | --- |
| N-Bits Flip Flop | 30 | 1000 |
| Delayed Discrimination | 20 | 100 |
| Sine Wave Generation | 30 | 100 |
| Path Integration | 30 | 100 |

## Appendix D Permutation-independent distance between weights

To quantify the dissimilarity between recurrent weight matrices in a permutation-independent manner, we use a variant of the Frobenius norm that allows for optimal row and column permutations.
Given two RNNs with weight matrices $\mathbf{W}_{1}\in\mathbb{R}^{n\times n}$ and $\mathbf{W}_{2}\in\mathbb{R}^{n\times n}$, we define the Permutation-Independent Frobenius (PIF) distance as:

$$ $d_{\text{PIF}}(\mathbf{W}_{1},\mathbf{W}_{2})=\min_{\mathbf{P}_{1},\mathbf{P}_ {2}\in\mathcal{P}(n)}\|\mathbf{W}_{1}-\mathbf{P}_{1}\mathbf{W}_{2}\mathbf{P}_{ 2}\|_{F}$ $$

where $\mathcal{P}(n)$ is the set of permutation matrices of size $n\times n$, and $\|\cdot\|_{F}$ denotes the Frobenius norm.

This distance is calculated using an iterative coordinate-descent optimization strategy with multiple random restarts to avoid local minima.
At each iteration, both the row permutation $\mathbf{P}_{1}$ or the column permutation $\mathbf{P}_{2}$ is optimized using a linear-sum-assignment approach as described in (Ainsworth et al., ).

## Peer Reviews

confidence: 5
contribution: 3
initial_rating: 5
presentation: 4
questions: Questions
Major questions:
* What is the distribution used to initialize the weights of the RNNs? How does the initial weight distribution affect the results? In particular, does the DSA distance still decrease with task complexity when initializing the RNNs with small weights close to zero?
* Why use a Frobenius invariant norm to measure weight degeneracy instead of an orthogonal invariant Frobenius norm as measured in DSA?

Additional questions:
* In general, how does the degeneracy evolve during training? Does it increase or decrease with training? This might depend on the weight initialization.
* It would be interesting to look at other more commonly used similarity measures than DSA such as CKA or Procrustes distance.
soundness: 2
strengths: * The study addresses an important question on diversity and degeneracy in RNNs.
* The authors investigate this question across multiple levels: behavior, dynamics, and connectivity, and across multiple settings: different loss functions, network sizes, and weight regularization methods.
* The paper is clearly structured and easy to follow.
summary: Summary
The authors study the variability in RNNs across four tasks: a flip-flop task, a delay discrimination task, a sine wave generation task, and a path integration task. For each of these tasks, the authors propose a way to vary the task complexity, as measured by the entropy of the inputs and outputs. They found that the average DSA pairwise distance between 50 RNNs trained to reach a certain performance threshold, decreases as the task complexity increases. On the other hand, the degeneracy of the RNN weights, measured with a permutation invariant Frobenius norm, was found to increase with task complexity. RNNs trained on more complex tasks also showed decreased variability in their outputs when evaluated on the original tasks with longer time durations. Additionally, the authors showed that the weights and dynamics degeneracy varies depending on the task loss, the network size, and the weight regularization method.
weaknesses: Weaknesses
It seems that the central claim of the paper is: “while harder tasks lead to more consistent neural dynamics across task-trained networks, their underlying recurrent weight matrices are more degenerate/variable.” (Section 4). However, this statement may be overly simplistic and may significantly depend on factors that were not considered in the proposed work:
(a) Dependence on the initial weight distribution of the RNNs
(b) Dependence on the specific distance metrics used to quantify dynamics and weights degeneracy
(c) Dependence on the specific notion of complexity

(a) Prior work has shown that the initial weight distribution can have a large influence on the training dynamics and the solutions found by the RNNs. However, there is little information on how the RNN weights were initialized and there is no analysis on how the main claims may depend on their initial distribution. In particular, the decrease in dynamics degeneracy with task complexity may not hold for RNNs initialized with small weights with values close to zero.

(b) The authors measured weights degeneracy with a stricter Frobenius norm than the dynamical degeneracy. The norm used for DSA is invariant under orthogonal transformation, which is less strict than the permutation invariant norm used to quantify the weights degeneracy. The authors found that dynamics degeneracy decreases with task complexity but weights degeneracy increases. How much does this result depend on the specific norm and its invariance class used to measure degeneracy? Would the weights degeneracy decrease with task complexity when considering a similar matrix norm than for the dynamics degeneracy, i.e. orthogonal transformation invariant Frobenius norm?

(c) The authors quantify task complexity as the entropy of the task inputs and outputs. However, this captures only a specific aspect of the task complexity. For example, as stated in section 4:  “Moreover, as we modified the task characteristics to study its effect on degeneracy, we observed that degeneracy remains invariant under certain transformations of the task, e.g., changing the delay duration in Delayed Discrimination or altering the environment size in Path Integration tasks.”. It would be really interesting to see these results because increasing the duration of the delay period or increasing the size of the environment can be seen as ways to make the tasks more complex, in the sense that it would probably take longer for the RNNs to learn the tasks. The amount of training required to learn the task is another metric that can be used to measure task complexity. It would be interesting to study how it relates to the entropy based task complexity considered by the authors.

Measuring task complexity as the entropy of the task inputs and outputs implies that it is invariant under shuffling of the timesteps, which completely changes the task structure. Does the relationship between degeneracy and task complexity still hold when considering time shuffled variants of the tasks?

---

confidence: 3
contribution: 1
initial_rating: 3
presentation: 3
questions: How does your permutation-independent distance contrast with the distance provided in Generalized Shape Metrics on Neural Representations paper Eq. 6?

It is written that "within each task, larger marker size and less opacity indicate task variant with higher complexity." Did the authors mean larger markers size and _more_ opacity? If not, I don't think your figure is interpretable.

For out of distribution tasks: What was the reasoning behind showing the CV but not mean error? Can you also show mean error and standard deviation separately? 

What is the reasoning behind doubling the delay period or entire trial for OOD part?
soundness: 2
strengths: The authors tried their method in various tasks and settings. 

The authors goal of measuring and controlling the degeneracy across different scales is very important and I think an important question.

The figures are very explanatory and the paper is written well, easy to follow.
summary: The paper provides ways of how to measure the behavior, dynamics, and weight-space degeneracies in RNNs, and then they provide methods to control these degeneracies. They show their findings using various tasks.
weaknesses: "We chose this measure because it directly reflects the amount of information present in the task’s inputs and outputs, which the network must process and represent through its hidden state (Tishby et al., 2000)." In the experiments done in paper, the dimensions of the RNNs are most of the time higher than the dimensions of your input and output. I do not understand how does this method (of measuring the entropy of input and output _separately_) works, in the case when the goal of an RNN is to reproduce its input? Say one presented a highly complex input signal. And since the goal is to reproduce, then the output signal is also highly complex. But, the RNN only needs to implement an identity function, but the method suggested would classify this as a difficult task. I think this clearly demonstrates the problem of taking into account the input and output signal separately. At the end of the day, the goal of an RNN is to _map_ its inputs to outputs, so to the best of my understanding, there lies a significant problem in this approach. Since authors base all of their claims to this methods, I am highly confused and would like to have a discussion about this. 

Controlling methods are only tried in one task but the results are written in general form. The claims in the paper, I believe could only be made if the authors have tried these methods on different tasks.

In the task settings in the paper I think it is true that increasing the number of channels makes the task more difficult, but I don't think it is always the case. Consider the delayed match-to-sample task. One can either have two different input channels to represent your signals or one. I think in this case representing with two channels makes the task easier. Does this show that this method is _not_ task agnostic?

Fig 4A, third column does not support your claim but you did not discuss it.

Auxiliary loss: I do not believe the defined auxiliary loss is in fact _auxiliary_ in the delayed discrimination task. When the task of a RNN is to output f1-f2 together with sign(f1-f2), I believe the main task becomes the former one.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: 1. As hinted at in the weaknesses, it's unclear if this measure relates to the true underlying generative process. Can they authors provide additional details on the generative processes' of these tasks (i.e where the uncertainty is, for instance in the delay period, or the probability of the bit-flip) and instead provide increased/decreased complexity of tasks based on this, and if the central claims of the paper still hold?
2. As detailed in 3.1, entropy calculated is discrete, however some tasks are continuous, yet no detail is provided on how binning can affect the final measure of H_{task}. Can the authors provide some results on this, and how this might change the 3 clusters of tasks they observe?
3. Can the authors provide any justification for why a joint/conditional/marginal entropy on input & output wasn't used? 
4. Fig 2: while the general trend of more PCs are needed for more complex tasks, how can this trend be reconciled across tasks? For instance DD (high input, low output) needs more PCs than the most "complex" n-bit task. Similarly, the opposite is observed for path integration (fewer PCs) and n-bit which have similar complexity measures. 
5. Fig 2: For panel E can the authors use either % or decimals consistently for variance?
6. Fig 3: Can the authors provide some justification or discussion for the trends observed, as the current writing goes it is unclear why such a trend makes intuitive sense. For instance, why does the output task complexity provide this trend v/s the input task complexity?
7. Fig 3: While the trend stated holds for same tasks with higher complexity, can the authors provide clarification on why between tasks this isn't observed? For instance sin-N and n-bff have similar output complexity measures but vary on DSA values. Can the authors provide some insight/clarification on this?
8. It appears the authors use different hidden dimensionalities in RNNs between tasks (i.e 64 v/s 128) while showing how their measure of task-complexity relates with degeneracy. As discussed in 3.3 this influences the capacity of the network. Can the authors provide a justification for why this was done and how the trends remain the same/change if all networks have the same dimensionality?
soundness: 2
strengths: The proposed method provides a unified approach to understanding the wide range of solutions in task-trained RNNs. The authors present multiple reasons/possibilities for these solutions (i.e due to behavioral, weight space or neural dynamic variability), and quantify its relationship with the amount of information present in each task. The information theoretic approach provides a way to categorize more complex v/s less complex tasks, which is then used to observe trends with other covariates. The authors further increase same task complexity by increasing the amount of information associated with the task (by adding independent channels). Their results suggest a similar trend in complexity with weight space degeneracy, and an inverse trend for neural dynamics and generalization. Lastly, they use these insights to increase/decrease the solution-space associated with tasks.
summary: This paper presents an approach to explore & control the solution space of task-trained vanilla RNNs. They provide an information theoretic approach to measure task complexity and provide empirical results on its correlation with behavioral, weight space and neural dynamic degeneracy. Lastly, the also provide ways in which such degeneracy of solutions can be controlled. Their results are performed on four neuroscience inspired tasks.
weaknesses: I have some main concerns/weakness which I will outline here with specifics under questions.

1. The authors present an interesting approach to quantify task-complexity using entropy. However, as detailed in the paper, this is very closely tied to the probability encoding the underlying generative process for each task. Specifically, while adding channels increases the information, a more robust measure would be changing the probability of the generative process (for instance the probability of a bit flip in a single channel). While in principle adding channels increases information associated with tasks, it's unclear if this is representative of the "randomness of the task".
2. The authors discuss ways to control solutions associated with task-trained RNNs. Other than increasing task-complexity and noting it's trend associated with weight and dynamical degeneracy (presented in this paper), the other four methods have been previously observed. Further, the authors do not provide any theoretical or discussion regarding how this relates to the method presented in this paper. Can the authors expand on the novelty of this section?

---

confidence: 4
contribution: 2
initial_rating: 3
presentation: 4
questions: Please see the questions in the Weaknesses before.
soundness: 3
strengths: - The paper is structured and clear.  
- Jointly considering several degeneracy metrics (in particular DSA) and tasks is useful for the community.   
- The tasks considered are diverse and rooted in the literature, giving a considerable degree of generality to the results.
- The related works section is thorough and bridges to the feedforward literature
summary: The paper considers the effect of task complexity on “solution degeneracy”. The latter is characterized through examining how three measures behave as a function of task complexity: 1\) Similarity of the dynamical system between trained networks, 2a) difference in weights from initialization and 2b) pairwise similarity of weights between trained networks, and 3\) difference in generalization performance between trained networks. 

### Recommendation
Overall, I think the paper is a valuable survey of the influence of task complexity on degeneracy and am looking forward to see it published. The main issue I see is with how expected the results are, depending on the way that it is regularized: An underconstrained system (as per less input-output channels) will be more variable due to unconstrained directions in the dynamics. If regularization in training, as is common practice, would turn out to remove for example DSA variability, I would not find the results sufficiently novel for ICLR. Until this point is clarified, I cannot recommend the paper to the conference.
weaknesses: (more important points first)

- **Regularization.** I could not understand from the paper whether a weight penalty was present when training on the task loss with BPTT. Weight decay for Adam is not specified, I assume it is the default, in case of which there would be some penalty. Was this the case, and if not, how would the measures change if the penalty got increased? For a stronger penalty, I would expect that the DSA metric shows less variation, as presumably noise directions that give rise to dynamical variability would then be penalized to decay. This would make the paper's finding much less interesting to me, because we already know that controlling task-unrelated dimensions is useful. I wonder for example whether Fig. 7 would be induced by strong regularization, biasing the network towards the presumably simpler line attractor solution.
- **Expectedness.** As the authors state in the discussion, most of the results can be understood with the following argument: As task entropy increases, the network parameters are increasingly constrained. Hence, there are less parameters that are unconstrained and give rise to degeneracy: Effectively, the network has now to solve $N$ tasks in parallel, but has the same representational capacity.   
  This makes me wonder how the metrics change when task complexity is not scaled up by replicating the same task over channels, but changing the complexity of the function that needs to be learned? As a very simple and probably too naive example, how would the network behave if task complexity was controlled by the number of Fourier modes in the target signal? It seems that the paper identifies a specific kind of task complexity whose generality is questionable: The proposed measure is not rooted in the literature apart from a loose connection to information theory.
- **Weight degeneracy.** I find the metric not well motivated. Why should I expect a pair of networks that is non-degenerate (i.e., similar in some way) to have small $d\_{PIF}$? Would I not rather consider an (orthogonal) similarity measure on matrices, for example $d\_{sim} \= min\_O ||W\_1 \- O^{-1} W\_2 O||\_F$, where $O$ is an orthogonal or general invertible matrix. This is exactly the $d\_{procrustes}$ the authors discuss for DSA. I expect that using this metric on the weights would essentially make it the DSA metric. It would be especially interesting if that changes Table 1\.  
- Do the authors have a hypothesis why change weight degeneracy depends on control paradigm?
- **Relevance.** Why should we care about whether a networks solution is degenerate or not? I understand that it is interesting descriptively to know a connection between task parameters and degeneracy metrics, but I am not sure where I would need this knowledge.  The paper would benefit from discussing this. 
- **Controllability.** It is hard to generalize from the findings for controlling degeneracy from the DD task only. For example, it is hard to say what an auxiliary loss term would look like for the other tasks, possibly involving some amount of engineering. 
- **Generality.** Do the authors suspect that there a tasks where the observed trends do not hold?
- No code is supplied, limiting transparency and reproducibility.

Again, I like the paper and think it is a valuable contribution, but these points make me question its novelty and generality.

---

confidence: 2
contribution: 2
initial_rating: 5
presentation: 3
questions: Please see the Weaknesses part.
soundness: 3
strengths: 1. This paper proposes a unified approach to analyze the degeneracy of solutions obtained by RNNs on several tasks from several perspectives.

2. This paper incorporates certain measures from information theory to quantify task complexity. The authors conclude that an increase in task complexity will lead to a reduction in degeneracy in neural dynamics and generalization behavior. However, it will simultaneously increase the degeneracy in weight space.

3. Based on their analysis, the authors propose several strategies for controlling solution degeneracy in practical applications.
summary: This paper proposes a unified approach to quantifying and controlling the degeneracy of solutions obtained by RNNs on several tasks by analyzing their degeneracy from three levels: behavior, neural dynamics, and weight space. They introduce some measures from information theory to quantify task complexity and conclude that increasing task complexity will reduce degeneracy in neural dynamics and generalization behavior, but increase the degeneracy in weight space. Based on these discoveries, they propose several strategies to control solution degeneracy in practice.
weaknesses: 1. The results in this paper are empirical and lack of theoretical analysis. For instance, it would be better if the authors could add more discussion on the reason why increasing task complexity will increase the degeneracy in weight space. Maybe some theoretical analysis of some toy examples will help. 

2. The strategies proposed for controlling solution degeneracy in practical applications are too general and may not be very useful in practice. For example, increasing task complexity reduces dynamical degeneracy and increases weight degeneracy, it is not clear which strategies we should use for specific tasks. More discussions on this aspect are welcome.

Meta-review: This paper proposes a unified information theoretic approach to quantifying and controlling the degeneracy of solutions obtained by RNNs on several tasks by analyzing their degeneracy from three levels: behavior, neural dynamics, and weight space. The authors use their measures to study and control training RNNs on four very simple, neuroscience inspired tasks: a flip-flop task, a delay discrimination task, a sine wave generation task, and a path integration task.
The reviewers point out several strengths of the paper including: 1) The study addresses an important question on diversity and degeneracy in RNNs. 2) This question is studied across multiple levels and across multiple settings. 3) The presentation is clear and easy to follow.
The reviewers also raised several questions, partly asking for clarification, partly pointing out possible flaws in the approach, and partly questioning the relevance of the proposed method. 
The authors decided that these comments warranted additional experiments which they were unable to complete in time. Rather than engaging in a discussion they decided to just thank the reviewers for their valuable feedback.
Based on the reviews and the authors reaction I recommend rejecting this paper, and look forward to seeing an improved resubmission at a later point.

Decision: Reject