Distinguishing Learning Rules with Brain Machine Interfaces
Abstract
Despite extensive theoretical work on biologically plausible learning rules, clear evidence about whether and how such rules are implemented in the brain has been difficult to obtain.
We consider biologically plausible supervised- and reinforcementlearning rules and ask whether changes in network activity during learning can be used to determine which learning rule is being used.
Supervised learning requires a credit-assignment model estimating the mapping from neural activity to behavior, and, in a biological organism, this model will inevitably be an imperfect approximation of the ideal mapping, leading to a bias in the direction of the weight updates relative to the true gradient.
Reinforcement learning, on the other hand, requires no credit-assignment model and tends to make weight updates following the true gradient direction.
We derive a metric to distinguish between learning rules by observing changes in the network activity during learning, given that the mapping from brain to behavior is known by the experimenter.
Because brain-machine interface (BMI) experiments allow for precise knowledge of this mapping, we model a cursor-control BMI task using recurrent neural networks, showing that learning rules can be distinguished in simulated experiments using only observations that a neuroscience experimenter would plausibly have access to.
Introduction
In order to update synaptic weights effectively during learning, a biological or artificial neural network must solve the problem of credit assignment.
That is, a neuron must infer whether it should increase or decrease its activity in order to decrease the error in the behavior that it is driving.
Supervised learning (SL) provides one approach for solving the credit assignment problem by endowing the synaptic learning rule with a credit assignment mapping , i.e. an estimate of how each neuron’s activity affects the behavioral readout.
Indeed, gradient-based methods such as backpropagation for feedforward networks and backpropagation through time for recurrent networks do exactly this by multiplying a (possibly multi-dimensional) readout error by the downstream readout weights in order to update hidden-layer synaptic weights.
However, because neurons in a biological neural network likely lack complete information about their downstream projections, ideal credit assignment mappings such as those used in gradient-based methods are biologically implausible–an issue known as the weight transport problem [1, 2, 3].
Recent work has shown that effective supervised learning in both feedforward networks and RNNs can still take place as long as there is a positive overlap between the true readout weights and the credit assignment matrix used for learning, providing one possible solution to this problem [4, 3, 5, 6, 7].
Reinforcement learning (RL) is another approach for solving the credit assignment problem.
Node perturbation algorithms correlate noise injections with scalar reward signals in order to update network weights [8, 9, 10].
Such algorithms avoid the weight transport problem, as the update rule does not explicitly require a credit assignment matrix mapping the vector error back to the recurrent weights.
While the weight updates for algorithms in this family tend to be noisy, the policy-gradient theorem guarantees that they tend to follow the true gradient of the objective function (Appendix B.2, [8, 11]).
Brain-machine interfaces (BMI) provide an ideal paradigm for investigating questions about learning and credit assignment in real brains, as they enable the experimenter to define the mapping (the “decoder”) from neural activity onto behavior.
For example, monkeys can be trained to control a cursor using a BMI in the motor cortex, and the behavior can be relearned following different manipulations of the BMI decoder in the course of a single day [12, 13, 14] or over the course of multiple days [15, 16, 17].
In the case of BMIs, the weight transport problem is particularly acute, since the readout weights mapping the neural activity onto the cursor position may be changed abruptly by the experimenter, and there is no plausible way for the agent to generate an instantaneous estimate of the new readout weights in order to then apply a learning rule.
If an agent is to use a credit-assignment model at all in such a task, it must consist of a weight matrix that imperfectly approximates the readout mapping, i.e. a biased internal model of credit assignment.
We refer to this as the decoder alignment problem .
The key insight in our work is that, under an SL rule, the agent will invariably perform credit assignment using a biased credit-assignment model, whereas no such model is required under a policy gradient-like RL rule.
Using this insight, we develop a framework for modeling BMI experiments with recurrent neural networks (RNNs
) using biologically plausible versions of SL and RL.
We show that an imperfect credit-assignment model introduces a systematic bias in the weight updates, as well as the direction in which neural activity evolves during learning.
Under the assumption that SL is biased but RL is not, this therefore provides a means by which to distinguish these different learning strategies.
We derive a statistical metric for comparing observed changes in neural activity with the changes predicted assuming knowledge of the BMI decoder, and we show how this metric can be used to detect learning bias in our simulated experiments.
While we focus on distinguishing biased
SL from unbiased RL, the approach described here could be used more generally to distinguish different biased vs. unbiased learning rules—or even biased learning rules with two different types of bias—from one another
Related work.
While there has recently been a renaissance of research on biologically plausible learning rules [4, 10, 6, 18, 5, 3], there has been relatively little work on how such proposals might be experimentally verified in neural experiments.
Lim et al.
[19] inferred hyperparameters of a Hebbian learning rule based on neural activity from a visual cortical area in monkeys.
Their work, however, assumed a single class of learning rules rather than trying to distinguish between multiple classes.
Nayebi et al.
[20] showed that different optimizers and hyperparameters used to train convolutional neural networks can in principle be distinguished by a classifier based on both weight changes and neural activations.
However, the classifier was trained using ground-truth data about the identity of the learning rule, which is the very thing that we aim to infer in our model.
Kepple et al.
[21] proposed a curriculum-based method for discerning the objective being optimized with SL and showed via RNN modeling that different objectives lead to distinct task-acquisition timescales.
While their approach analyzed evidence accumulation and decision tasks and focused on distinguishing different objectives, we focus primarily on continuous control tasks and on distinguishing learning rules.
While Feulner and Clopath [22] simulated BMI learning with RNNs to compare learning that required changes within vs. outside of the intrinsic manifold of neural activity, and Feulner et al.
[23] used a similar approach to analyze how learning at upstream or recurrent synapses affected the covariance of neural activity, neither of these studies attempted to distinguish learning rules.
To our knowledge, our study is the first to propose a framework for distinguishing between learning rules using BMIs.
[Figure]
scalarreward
[Figure]
Theoretical approach
The overall approach for our work is shown schematically in Fig.
We train RNNs to perform a BMI-inspired cursor-control task using different learning rules, with the goal of analyzing the observed activity to infer the learning rule that was used to train the network.
Inspired by numerous BMI experiments [12, 24, 16], we pre-train the RNN using a particular choice of decoder weights, then require the RNN to relearn the task using a new set of decoder weights.
Our main result is to predict the different ways in which the RNN activity is expected to evolve through learning, then to compare these predictions with the observed changes in the activity in order to infer the learning rule.
In the sections that follow, we first introduce the SL and RL update rules that are used for training our networks.
We then show that they lead to distinct predictions about how the RNN activity is expected to evolve with training.
The remainder of the paper presents empirical results showing that the learning rules can be inferred by observing the network activity, first for a relatively simple case and then under more generalized assumptions.
While our main results can be obtained using either a feedforward or recurrent circuit model, we mostly focus on the latter case because BMI experiments typically involve control tasks driven by time-varying activity in motor cortex, for which an RNN model is more appropriate.
The feedforward version of our results is provided in Appendix A.
2.1 Modeling BMI learning with RNNs
We model motor cortex as a vanilla RNN characterized by input weights W in , recurrent weights
W rec , feedback weights W fb , and BMI decoder weights W bmi .
Since the experimenter has complete control over the decoder in a BMI experiment, we treat W bmi as fixed and assume that learning occurs in recurrent weights W rec alone.
The activity of the recurrent units h t is given by
[Equation]
where τ is the RNN time constant, ϕ ( · )
= tanh( · ) is a nonlinear activation function, x t is an input signal, and ξ ti ∼ N (0 , σ 2rec ) is isotropic noise added to the recurrent units.
This activity is read out by W bmi to obtain the cursor position
y tk = (cid:80)
i W bmi ki h ti .
The error at each time step is defined as ϵ t k = y ∗
tk − y
tk , where y ∗ t is the target output for each time step.
The loss to be minimized is then L = 12 T (cid:80)
Tt =1 (cid:80) N y k
=
( ϵ tk ) 2 where T is the trial duration and N y
= 2 is the number of readout dimensions.
Supervised learning.
Standard supervised algorithms for RNNs such as Backpropagation Through
Time [25] and Real-Time Recurrent Learning [26] are widely acknowledged to be biologically implausible.
The reasons for this are two-fold.
First, both algorithms assume knowledge of the readout weights for purposes of credit assignment, which we referred to above as the weight transport problem.
Second, updating a particular recurrent weight with one of these algorithms requires knowledge of all of the other weights in the network, which is not information that a biological neuron would likely have access to.
A recently proposed alternative, Random Feedback Local Online (RFLO) learning [5], is an approximate gradient-based algorithm with ∆ W rec ≈ − ∂L/∂ W rec that addresses these problems by (i) assuming that error information is projected back into the network with weights that imperfectly approximate the ideal credit assignment mapping, and (ii) dropping nonlocal terms from the update rule.
The recurrent weight update with this learning rule is
[Equation]
with u ti = (cid:80) k W rec ik h t − 1 k + (cid:80) k W in ik x tk
+ (cid:80)
k
W
fb
ik y tk , and p tij
≈ ∂h
ti /∂W rec ij .
Further details are provided in Appendix B.1.
The learning rule that we implement differs slightly from RFLO in that the readout weights, as in a BMI experiment, are fixed during training rather than learned.
In
RFLO, learning of the readout weights was required in order to align the readout weights with the credit assignment matrix.
Here we will instead assume that the credit assignment matrix M is fixed and partially aligned with ( W bmi ) ⊤ , so that the cosine similarity of the flattened matrices satisfies sim( M , ( W bmi ) ⊤ ) > 0 .
In (2), the credit assignment mapping M ik assigns responsibility for the readout error ϵ tk to neuron i .
While the ideal mapping would be M =
( W bmi ) ⊤ , learning can still be effective as long as there is a positive alignment between M and ( W bmi ) ⊤ [5] (as shown previously in the case of feedforward networks [4]).
In the case where they are not equal, as we presume they cannot be in a BMI experiment, the matrix M constitutes a biased credit-assignment mapping.
Below, we show that this leads to a predictable bias in the change of the RNN activity as the task is learned.
Example output trajectories from an RNN trained on the cursor-control task with the SL rule described above are shown in Fig.
2A.
The results in Fig.
2B show that learning the task is possible whenever there is partial alignment between M and ( W bmi ) ⊤ , and that faster learning occurs as this alignment increases.
Reinforcement learning.
To train RNNs with RL, we use a node perturbation learning rule closely related to REINFORCE [8].
We first define a scalar reward R t =
−| ϵ t | 2 .
Node perturbation seeks to increase this reward by trial and error using the noise appearing in the recurrent population activity in (1).
If the noise to a given neuron causes the reward to increase, then the weights will be updated so that that neuron’s input will be greater in subsequent trials.
Including an eligibility trace in the learning rule further makes it possible to assign credit for changes in reward to noise events at previous time steps.
Finally, we can subtract off a baseline from the reward so that learning is guided by a reward prediction error, which somewhat decreases the variance of the weight updates without introducing bias [11].
The resulting learning rule, which we derive using the policy gradient theorem [27, 11] in Appendix B.2, is
[Equation]
Very similar RL rules for RNNs have been previously proposed and studied in Refs.
Importantly for our purposes, the fact that this learning rule is derived using a policy gradient approach guarantees that, upon averaging over isotropic noise, the weight updates follow the true gradient of the loss function (in our case given by L = − 12 (cid:80) t R t ), making this an unbiased learning rule.
Like (2), (3) does not have nonlocal terms.
Example output trajectories and the learning curve from an RNN trained on the cursor-control task using (3) are shown in Fig.
2D,E.
2.2 Characterizing changes in neural activity with vector flow fields
Because observing changes in neural activity is much more straightforward than observing changes in synaptic weights in neuroscience experiments, we aim to identify experimentally observable signatures in the neural activity that might distinguish biased SL from unbiased RL.
Because the
RNN activity consists of time-dependent trajectories, and changes in the weights will generally affect entire trajectories cumulatively from one time step to the next, calculating the change ∆ h t due to an update ∆ W rec is not entirely straightforward (though cf.
the feedforward case described in Appendix
A, where this can be done).
A more useful approach is to quantify the learning-induced change in the vector flow field that shapes the RNN activity, where the flow field can be estimated empirically by observing neural activity trajectories.
To do this, we linearize (1), assuming ϕ ( u ) =
u , to obtain an expression for a vector flow field function F ( h ) that maps activity h t −→ h t +1 and is defined for all points h in neural activity space:
[Equation]
where, in our simulations, ∆ t = 1 .
Thus, from (1), we see that F ( h t )
≈ h t
+∆ t − h t .
If the recurrent weights change according to W rec → W rec + ∆ W rec , then the flow field exhibits a corresponding change F → F + ∆ F ,
where ∆ F ( h ) = 1 τ ∆ W rec h .
This equation enables us to relate changes in
W rec to changes in neural activity (note that this assumes that plasticity is occurring in the recurrent weights W rec alone, and that W in and W fb do not change).
As illustrated in Fig.
1D, our approach will be to (i) predict the expected change in flow field ∆ F pred ( h ) under either SL or RL, (ii) estimate ∆ F obs ( h ) empirically using activity observed early and late in learning, and (iii) determine which learning rule was used to train the network by comparing the empirically observed vs. predicted flow field changes.
In order to predict the flow field change in the SL case for a point h in neural activity space, we predict the direction of weight change using an approximation of (2):
[Equation]
where n refers to trials, and n ∈ mid denotes that we sample from trials during the middle part of training, when most of the learning is presumed to take place.
In the RL case, we similarly predict the direction of weight change using an approximation of (3):
[Equation]
In this equation, Σ is the recurrent noise covariance, which, under conditions of isotropic noise, reduces to a prefactor σ 2rec I .
Importantly for our purposes, the predicted changes in flow field from (5) and (6) depend entirely on quantities that are known or can be estimated from experimental data, including W bmi , as well as samples of h n,t and ϵ n,t .
As shown in Section 3.4 below, M can also be estimated from data.
Because we are asking only about changes in the flow field rather than the flow field itself, these quantities do not depend explicitly on the recurrent connectivity W rec itself, which is presumably unobtainable experimentally.
The key distinction between (5) and (6) is that the change in flow field in the SL case depends on M , while the change in flow field in the RL case depends on ( W bmi ) ⊤ .
We motivate (5) and (6) by computing ⟨ ∆ W rec ⟩ for each learning rule (averaging over noise) in Appendix B. and Appendix B.2, respectively.
We provide empirical evidence that updates approximately follow a consistent direction for each rule in Appendix C.5.
Next, we wish to estimate the empirical change in the flow field given neural activity observed at different points in learning.
The approach is somewhat simplified if we assume that the trials during which learning takes place are preceded and followed by “early” and “late” blocks of trials, in which the performance is observed but the weights are not updated.
The assumption that the amount of learning during these early and late blocks is negligible is justified in the limit where the learning rate is small and the number of training trials is large.
(Evidence that our main results do not depend strongly on this assumption is given in Appendix A, where learning was allowed to take place during the early and late blocks.)
Then, from (4), we define the observed flow field from time step t in trial n as either F early ( h ) =
( A early − I ) h or F late ( h )
=
( A late − I ) h , where A early is the least-squares solution to the autoregression equation h n,t +1 =
A early h n,t for all time steps t in all early trials n , and A late is the corresponding solution for late trials.
The empirical change in the flow field due to learning for any point h is then given by ∆ F obs ( h ) =
F late ( h ) − F early ( h ) .
[Figure]
BPTT sim sim
[Figure]
sim
[Figure]
sim
[Figure]
Trials
[Figure]
[Figure]
Lo ss
[Figure]
SE
[Figure]
0.4 0.5 0.6 0.7 0.8 0.9sim( M , ( W bmi1 ) ) 0.
C o rr ( F ob s ,
F p r ed )
Train with SL
RL
SL 0.
sim( M , ( W bmi1 ) ) 0.
[Figure]
Train with RL
SL( M )
RL
[Figure]
Having defined the observed and predicted changes in the flow fields for arbitrary h , we can define the correlation between these quantities as
[Equation]
We refer to this as the flow field change correlation (FFCC).
One important point to note is that, because this quantity is computed only at observed values of h n,t , it is not the case that the flow field needs to be estimated everywhere in the high-dimensional space of neural activity.
If the activity tends to occupy a low-dimensional manifold within this space, then the flow field needs to be determined only within this manifold.
Another point to note is that this metric is independent of the magnitudes of ∆ F obs and ∆ F pred , so that it does not depend on overall prefactors such as the learning rates and network time constant.
In the simulations that follow, the correlation metric (7) will be computed separately under our two hypothesized learning rules, i.e. with ∆ F pred = ∆ F predSL and with ∆ F pred = ∆ F predRL .
While the absolute magnitudes of this quantity are not informative on their own, we show below that the relative values can be compared to infer which of the two learning rules is more likely to have generated the data.
Simulation results
In this section, we use the theory outlined above to show that the SL and RL rules we consider can be distinguished in simulations, first in a basic case with simplifying assumptions, and then in more realistic cases where these assumptions are relaxed.
C
D
E
[Figure]
Learn M
Trials 0.
C o rr ( F ob s ,
F p r ed )
Train with SL
RL
SL sim( M , ( W bmi1 ) )
(strength of W fb ) 0.5     0.
C o rr ( F ob s ,
F p r ed )
Train with SL
RL
SL 0.5    (strength of W fb ) 0.
C o rr ( F ob s ,
F p r ed )
Train with RL
RL
SL
In order to emulate monkey BMI experiments (e.g., [12, 16, 15, 13, 14]) we first pretrain the recurrent weights W rec of an RNN with fixed, random readout weights W bmi0 to perform a center-out cursorcontrol task, in which a cursor must be moved to one of four target locations specified by the input to the RNN. We then change the BMI decoder to W bmi1 , make identical copies of the network, and train one with SL using credit-assignment mapping M and the other with RL. For these simulations, shown in Fig.
2, we make the following simplifying assumptions (to be generalized in later sections):
(i) the credit assignment mapping M is fixed and known; (ii) the feedback weights W fb are zero; and (iii) the noise ξ t ∼ N (0 , σ 2rec I ) is isotropic.
For the networks trained with biased SL and sim( W bmi0 , W bmi1 ) = 0 .
5 , we find that a comparison of the observed and predicted flow field changes correctly detects the bias (Fig.
2C).
As we vary the alignment between M and ( W bmi1 )
⊤ , we find that the FFCC correctly detects the bias present during learning whenever these two matrices are sufficiently distinct.
For the networks trained with
RL, we find that the change in activity is aligned more closely to the prediction using true decoder
W bmi1 than when using a random matrix
ˆM that is partially aligned to W bmi1 .
As we increase the alignment sim( ˆM , ( W bmi1 ) ⊤ ) , this distinction is less discernible (Fig. 2F).
We show in Appendix
C.1 that these results are robust to changes in hyperparameters.
In the empirical results that follow, we will generalize the assumptions made thus far and show that there is a significant range of parameters where the results still hold.
In particular, we will consider the roles played by (i) estimation and/or learning of the credit-assignment model M , (ii) driving feedback via the weights W fb , and (iii) non-isotropic noise.
A
B
C
SL( M ) SL( M )
RL 0.
sim ( W bmi0 , W bmi1 ) 0.
Train with SL
C o rr ( F ob s ,
F p r ed ) 0.
sim ( W bmi0 , W bmi1 ) 0.
C o rr ( F ob s ,
F p r ed ) 0.
Train with RL
SL( M )
RL sim( M ,( W bmi0 ) )
[Figure]
[Figure] [Figure] [Figure]
[Figure] [Figure] [Figure]
[Figure]
A li gn m en t 3.2 Learning the credit assignment mapping In order to optimize learning in a supervised setting, a learner’s credit assignment mapping could improve over time to align more closely with the decoder (Fig. 3A). To investigate the effect of such learning in our model, we applied our analysis to an RNN in which recurrent weights W rec were trained with SL, with a biased credit assignment mapping M that slowly improved via weight mirroring , a perturbation-based algorithm for learning a credit assignment matrix [6, 18].
In our simulations (Fig.
3B), the alignment between M and ( W bmi1 ) ⊤ is initially set at 0 . 5 , then slowly increases as M is learned simultaneously along with the recurrent weights W rec . Instead of predicting the change in flow field before and after learning, we now apply our analysis over discrete windows during learning.
As expected, activity changes are biased—and hence the SL and RL learning rules are distinguishable—early in learning.
However, these differences disappear as M approaches ( W bmi1 )
⊤ later in learning.
3.3 Incorporating driving feedback
So far, we have not included driving feedback, which can strongly influence the dynamics of population activity.
We next included fixed driving feedback weights W fb = γ M and varied the strength of these weights by a scalar factor γ (Fig.
3C).
M was randomly generated such that sim( M , ( W bmi1 ) ⊤ ) = 0 .
Note that the networks trained with SL therefore used the same mapping
M for both the learning rule and for the driving feedback.
We found that bias in an RNN trained with
SL is correctly identified for a wide range of γ (Fig.
3D).
For RNNs trained with RL, we found that the correct learning rule is identified for weak feedback, but that the FFCC metric fails for strong driving feedback (Fig.
3E).
This is likely because neural activity in this limit is dominated by the contribution from W fb , which is fully aligned with M and less aligned to ( W bmi1 ) ⊤ .
3.4 Estimating the credit assignment mapping from observed activity
Our approach thus far estimates the extent to which the activity updates follow either the direction of the gradient defined by the decoder weights or the (possibly biased) gradient defined by the credit assignment mapping.
This estimation assumes knowledge of the credit assignment mapping M .
In a neuroscience experiment, however, this quantity would not be known a priori and would need to be estimated.
To obtain an estimate ˆM of M , we follow an approach previously used in experiments, in which dimensionality reduction is first applied to the neural data, followed by linear regression to relate the network activity to the cursor movements [12, 16, 22].
(A possible alternative approach could be to use the Internal Model Estimation framework proposed by Golub et al.
More specifically, we (i) pretrain the RNN with decoder W bmi0 and biased credit assignment mapping
M (where sim( M , ( W bmi0 ) ⊤ ) = 0 . 6 ), (ii) observe the activity and cursor trajectories produced by the trained network, (iii) perform principal component analysis on the network activity and relate the principal components to the cursor positions with linear regression, and (iv) use the regression coefficients to define the estimated credit assignment mapping
ˆM
= DC , where C is the matrix of principal-component eigenvectors and D is the matrix of regression coefficients.
Fig.
4A shows that the ˆM obtained in this way is similar to the true M used to train the RNN.
It is important to note for our aim of distinguishing learning rules that ˆM is more similar to M than to W bmi0 and correctly identifies the alignment between M and ( W bmi0 ) ⊤ .
We also see from Fig.
4A that this result depends only weakly on the number of principal components used to describe the network activity.
After estimating ˆM , we changed the decoder to W bmi1 and trained the network to proficiency with either SL (using M in the learning update) or RL (which doesn’t use M ).
For an RNN trained with
SL (Fig. 4B), the correct learning rule is identified using either the true M (red curve) or the estimated ˆM (brown curve) for low and intermediate degrees of similarity between W bmi0 and W bmi1 .
For an
RNN trained with RL (Fig. 4C), correct identification of the learning rule does not depend on the similarity between W bmi0 and W bmi1 .
Together, the above results show that, for a relatively wide range of parameters, the credit assignment mapping can be estimated from observed data, and that this estimate is sufficient to distinguish between learning rules used to train different networks.
3.5 RL with non-isotropic noise
In the theoretical and empirical results above, we have assumed that the noise covariance is isotropic.
If we instead allow for non-isotropic recurrent noise covariance Σ , we find that this covariance appears in the expected RL weight update (Appendix B.2).
As in feedforward networks [30], this introduces a bias in the weight updates, so that the noise-averaged weight updates no longer follow the true gradient.
Given that RL is no longer unbiased in this case, we thus asked under what conditions we might still be able to distinguish biased SL from RL.
We first established that the RNNs can learn a cursor-control task with non-isotropic noise via either
SL (trivially) or RL (as long as some of the noise is in the subspace of the decoder).
To do this, we pretrained networks with W bmi0 , changed the decoder to W bmi1 , and then trained using either SL or RL.
In the SL case, we chose a biased credit mapping M that has partial overlap with the new decoder, with sim( M , ( W bmi1 ) ⊤ ) = 0 .
The noise covariance was chosen to be d -dimensional, with rank( Σ ) =
d , and isotropic within those dimensions.
The first two of these dimensions were selected to lie in the subspace spanned by M for the SL-trained RNNs or by W bmi1 for the RLtrained RNNs.
Other components of Σ were added in random dimensions orthogonal to this subspace and to one another.
The results in Fig.
5 show that, when training with SL, we cannot reliably distinguish the learning rule used to train the network when the noise is very low-dimensional (Fig.
5B).
When training with
RL, however, the learning rule can be distinguished even with low-dimensional noise (Fig.
5C).
As the noise dimensionality increases, the learning rules become more easily distinguishable in both cases.
This remains true in the RL case even if we do not presume to know the true noise covariance matrix, but instead use a naive assumption of isotropic noise in order to generate the predictions (dark blue lines in Fig.
5B,C).
Discussion
In this work, we have proposed a method for distinguishing biased SL from RL under the assumption that the mapping from neural activity to behavior is known, as in a BMI experiment.
More generally, the approach could be used to distinguish between different candidate learning rules with different degrees or types of bias.
We have illustrated the approach by modeling a BMI cursor-control experiment in motor cortex, where there is ample experimental evidence for plasticity during motor learning [31].
Both SL and RL are plausible candidates for how motor learning might be implemented in the brain, either within motor cortex itself or within extended motor circuits involving motor cortex together with the cerebellum [32, 33, 34] or basal ganglia [35, 36].
One possible limitation of our approach is that the number of learning rules that might conceivably be implemented in recurrent circuits in the brain is much greater than the two that we have focused on here.
Nevertheless, we view the SL and RL rules considered above as representative examples of two fundamental classes of learning rules: one in which learning is based on a model for credit [Figure] rr ( [Figure]
F p r ed ) [Figure] assignment, where this model is necessarily imperfect, and another which uses no such model. While we cannot test every learning algorithm from these classes, we conjecture that the basic fact that allows us to distinguish our SL and RL rules—namely, that the expected flow field change depends on a credit-assignment matrix for model-based rules but not for non-model-based rules—is a fairly generic feature of these two classes.
To support this, we show in Appendix C.2 that our main results hold for a different version of the biased learning rule that we have studied.
While we have shown that different learning rules are in principle distinguishable in simulation, there will be challenges in extending this analysis to real data.
Reliable estimation of the FFCC metric might require large populations of neurons recorded for long periods of time.
Other potential challenges that will need to be addressed include accounting for the possibility that multiple types of learning might be occurring simultaneously at different locations, as well as considering cognitive mechanisms such as attention and contextual inference, which have not been included in this model.
Finally, there are possible ambiguities to consider in mapping our model onto the brain’s motor circuitry.
While the most straightforward interpretation is that the RNN in our model corresponds to motor cortex, a more elaborate interpretation could be made by noting that both the cerebellum and the basal ganglia have well-established roles in motor learning [37] and are likely to play roles in
BMI learning as well [36, 38].
Acknowledgments and Disclosure of Funding
The authors would like to acknowledge Larry Abbott, Andrew Zimnik, Laureline Logiaco, Kaushik
Lakshminarasimhan, and Vivek Athalye for fruitful discussions.
Thanks to Amin Nejatbakhsh, David
Clark, and Danil Tyulmankov for feedback on the manuscript.
Support for this work was provided by
NIH-NINDS (R00NS114194).
A Distinguishing supervised learning from reinforcement learning in a feedforward model
In order to illustrate the main idea from our paper in a simplified context, we show in this section how observed hidden-layer activity in a linear feedforward network can be used to infer the learning rule that is used to train the network.
Consider the simple feedforward network shown in Fig.
S1.
In this network, random binary input patterns x t , where x ti ∈ {− 1 , 1 } and t = 1 , . . .
, T , are projected onto a hidden layer h t =
Wx t + ξ t , where ξ t ∼ N (0 , Σ ) is noise injected into the network.
The readout is then given by y t
= W bmi h , and the goal of the network is to minimize
L = (cid:80) t L t = 1 T (cid:80) t | y ∗ t − y t | 2 , where y ∗ are randomly chosen target patterns with y ∗ i ∼ N (0 , 1) .
With W bmi fixed, we can train the network using either supervised learning (SL) or reinforcement learning (RL).
In the case of SL, the learning rule performs credit assignment using a model M that approximates the ideal credit assignment model ( W bmi ) ⊤ to project the error ϵ t =
y ∗ t − y t back to the hidden layer (Fig. S1A), giving the following weight update:
[Equation]
In the case where M = ( W bmi ) ⊤ , this rule would be implementing gradient descent.
In the case where M ̸ =
( W bmi ) ⊤ but the two matrices have positive alignment, it instead implements a biased version of gradient descent.
This is similar to learning with Feedback Alignment [4], except that here we do not assume that the readout weights are being learned.
An alternative learning algorithm is policy gradient learning [8], which gives the following update equation:
[Equation]
where we define the reward as R t = − L t , and we subtract off the baseline ¯ R t = ⟨ L t ⟩ ξ .
Our goal will be to train the network to minimize the loss using either the SL or RL learning rule, then, assuming W bmi and M are known, to use the observed output and hidden-layer activity during training to infer which of the two algorithms was used to train the network.
In the case of SL, averaging (8) over noise ξ gives
[Equation]
The expected change in the hidden-layer activity due to learning is then
[Equation]
In the case of RL, the average of the weight update from (9) is
[Equation]
The expected change in the hidden-layer activity in this case is then
[Equation]
Equations (11) and (13) provide predictions for how the hidden-layer activity is expected to evolve under either SL or RL.
Since we do not presume to have knowledge of either the learning rate or the upstream activity x t , we can concern ourselves only with the direction, but not the magnitude, of ⟨ ∆ h t ⟩ .
In addition, we must make an assumption about correlations between the input patterns.
In general, if the input patterns are correlated with one another, we can let x t · x t ′ =
C ( | t − t ′ | ) , where
C is a function with a peak near zero.
W
W bmi
[Equation]
A
B
C
D
E
F sim( M ,( W bmi ) ⊤ ) c
o rr( ⟨ Δ h ⟩ ob s , ⟨ Δ h ⟩ p r e d ) sim
( M ,( W bmi ) ⊤ )
c o rr( ⟨ Δ h ⟩ ob s , ⟨ Δ h ⟩ p r e d )
For the simulations shown in Fig.
S1, we have used uncorrelated inputs x t , so we can assume that x t · x t ′ ∼ δ tt ′ .
With this assumption, Equations (11) and (13) give
[Equation]
Thus, if we assume that the quantities M , Σ , and ( W bmi ) ⊤ are known or can be estimated, (14) provides a prediction for how the hidden-layer activity is expected to change due to learning.
If this quantity is estimated from data, then the average over noise can be replaced with an empirical average over observed trials: ⟨ . . .
[Equation]
If we next suppose that we observe the hidden-layer activity empirically without necessarily knowing the learning rule being used to train the network, then we can define the observed change in hiddenlayer activity as the difference between activity observed in early and late trials
[Equation]
where h n,t is the activity observed at time t in trial n .
We can then compare the similarity of ⟨ ∆ h t ⟩ obs with ⟨ ∆ h t ⟩ pred by computing their correlations:
[Equation]
where ( . . . ) denotes an average over neurons.
In Fig.
S1, we show results from a linear feedforward network trained with either SL (Fig.
S1A-B) or RL (Fig.
S1D-E)
to map random input patterns onto random output patterns.
Then, using (16), we ask whether the change in the hidden-layer activity during learning in each of these cases is more similar to ⟨ ∆ h ⟩ pred predicted assuming SL or RL.
The results in Fig.
S1C,F show that, whenever M and ( W bmi ) ⊤ are sufficiently different, this metric is able to correctly identify whether the network was trained with SL (Fig.
S1C) or RL (Fig.
S1F).
B Biologically plausible learning rules for recurrent neural networks
In this section we provide derivations of the two learning rules studied in our paper.
The RNN update equation is
[Equation]
(17) where u t =
W rec h t − 1 + W fb y t − 1 + W in x t , and ξ ti ∼ N (0 , σ 2rec )
is i.i.d.
noise injected into the network.
The readout is given by y = W bmi h t .
The goal of both learning rules is to iteratively update the recurrent weights W rec such that the readout matches a target function y ∗ t , minimizing the magnitude of the error ϵ t = y ∗ t − y t .
The learning rules that we consider below depend on a multiplicative combination of pre- and postsynaptic activity, as well as a third factor related to error or reward.
Evidence for such “three-factor" learning rules has been found in a number of neuroscience experiments [39].
B.1 Random Feedback Local Online (RFLO) learning
In this section, we briefly recapitulate the derivation of RFLO [5], a supervised learning algorithm for RNNs that uses local weight updates to approximate gradient descent.
We then compute the expectation of the weight update by averaging over noise and show that this expected weight update is determined by the credit-assignment matrix M .
The loss function to be minimized is
[Equation]
[Equation]
Taking the derivative with respect to the recurrent weights gives
[Equation]
Using (17), we obtain the following recursion relation:
[Equation]
To obtain a learning rule for W rec ab that is local, i.e. that depends only on pre- and postsynaptic activity from units b and a , respectively, we can discard the second line of this equation and write ∂h ti /∂W rec ab ≈ δ ia p tab , where the eligibility trace p tab follows the recursion relation
[Equation]
and p 0 ab = 0 .
With this approximation, we arrive at the RFLO learning rule:
[Equation]
[Equation]
In order to compute the expected change in the RNN flow fields, we wish to compute the expectation of the weight update (22) by averaging over noise.
In order to obtain a result for ∆ F that does not depend explicitly on W rec , we assume a linear network with ϕ ( u ) = u .
For convenience, we also switch to the continuous-time limit.
In this case, the above eligibility trace in (21) is given by
[Equation]
Thus, the expected weight update is given by
[Equation]
where we have defined the covariance matrix Q t,t ′ = ⟨ h t ( h t ′ )
⊤ ⟩ − ⟨ h t ⟩ ⟨ h t ′ ⟩ ⊤ .
In the case where τ is unknown (as it may be in experimental data) or sufficiently small relative to the timescale of RNN dynamics, this expression can be simplified by taking the limit τ → 0 , leading to
[Equation]
In the limit where the noise is small, the first term in parentheses will be much larger than the second, which can be dropped to obtain a simplified expression.
B.2 Reinforcement learning in recurrent neural networks
In this section, we derive a local RNN update rule using policy gradient learning.
The resulting “node perturbation” learning algorithm is essentially equivalent to previously proposed RL rules for recurrent circuits from Refs.
We then compute the expectation of the weight update (34) by averaging over noise and show that this expected weight update is determined by the decoder W bmi , following the unbiased gradient direction.
In policy gradient learning, a policy π (action | state) is optimized with respect to its parameters in order to maximize a scalar performance measure R t .
In our case, we interpret h t as the action, h t −as the state, and W rec as the parameters to be optimized.
We take the policy to be
[Equation]
26) where
[Equation]
is the deterministic part of the update equation (17).
The policy gradient theorem allows us to update the policy parameters in a way that ensures improvement of the objective R t .
The REINFORCE algorithm [8] is based on the policy gradient theorem and updates the parameters W rec according to
[Equation]
where the gradient is with respect to W rec .
The reward baseline ¯ R t , to be defined below, is not required for policy gradient learning but can decrease the variance of the updates [11].
The gradient can be computed as follows:
[Equation]
In order to address temporally delayed credit assignment, we can additionally incorporate an eligibility trace in the gradient appearing in (28), replacing ∇ ln π −→ ∇ ln π , where the bar denotes low-pass filtering [11].
This allows credit for rewards at time t to be assigned to the RNN activity at earlier time steps.
This leads to the following update rule:
[Equation]
where the eligibility trace is given by
[Equation]
with q 0 ab = 0 .
In our simulations, we set the timescale for the eligibility trace to be equal to the network time constant, i.e. τ e = τ .
In order to compute the expected change ∆ F pred in the RNN flow fields
[Equation]
we next wish to compute the expectation of the weight update (30) by averaging over noise.
As in the SL case from the previous section
[Equation]
we assume that the RNN is linear and switch to the continuous-time limit.
In this case, the eligibility trace is given by
[Equation]
The reward R t itself is given by
[Equation]
We assume that the expected reward ¯ R t is independent of the noise ξ , so it doesn’t contribute to ⟨ ∆ W rec ⟩ .
Then we can use Wick’s theorem to calculate the expected weight update:
[Equation]
For the linear network we are considering, we have ⟨ ξ si h tl ⟩ = (cid:80) m Σ
im (cid:0) e W ( t − s ) (cid:1) lm , where ξ s ∼
N (0 , Σ ) and W = − I
+ W rec + W fb W bmi .
Then
[Equation]
(cid:88)
[Equation]
In the case where τ e is unknown (as it may be in experimental data) or sufficiently small, this expression can be simplified by taking the limit τ e → 0 , leading to
[Equation]
As in the SL case, in the limit where the noise is small, the first term in parentheses will be much larger than the second, which can be dropped to obtain a simplified expression.
C Simulations C.1 Experimental details
The code used to run these simulations can be found at www.github.com/jacobfulano/ learning-rules-with-bmi
As stated in the main text, we first pretrain the recurrent weights W rec of an RNN with fixed, random readout weights W bmi0 to perform a center-out cursor-control task, in which a cursor must be moved to one of four target locations specified by the input to the RNN.
We then change the BMI decoder to
W bmi1 , make identical copies of the network, and train one with SL and the other with RL.
Multiple seeds ( n = 4 ) were selected for W bmi1 and M and applied to network copies in the training phase, and correlation metric results Corr(∆ F obs , ∆ F pred ) were averaged over these seeds.
Error bars are
S.E.M. Unless stated otherwise, all simulations involved pretraining.
Simulations for Figures 2 used 4 input dimensions, N = 50 recurrent units, and 2 output dimensions, with a trial duration of 20 timesteps.
The scale for the variance of the noise injected at each layer was σ 2in = 0 , σ 2rec = 0 .
25 , σ 2bmi = 0 .
01 for input, recurrent, and output units respectively.
Constant learning rate for recurrent weights was η rec = 0 . 1 , and the RNN time constant was set to τ = 10 .
Recurrent weights W rec were initialized with W rec ∼ N (0 , g 2 / √ N )
where g
= 1 . 5 .
Input weights W in and decoder weights W bmi were initialized randomly and uniformly over [ − 2 , 2] and [ − 2 / √ N, 2 / √ N ] respectively.
For all networks, the activation function was ϕ ( · ) = tanh( · ) .
Pretraining was run for 2,500 trials using SL, and training was run for 1,500 trials for SL and 15, trials for RL.
Alignment between M and W bmi0 was fixed at 0.5.
Input signals for each target consisted of a step function that was 1 for 20% of the trial duration (i.e. 4 timesteps) and 0 for the remainder.
Input to the network at each timestep was therefore a 4 dimensional vector with one entry equal to 1 and other entries equal to zero.
For both SL and RL algorithms, weights were updated at the end of each trial (i.e. “offline”).
For RL simulations using (3), a separate reward baseline ¯ R t was kept for each target.
In order to control alignment α between decoder weights ( W bmi ) ⊤ and matrices M , we generated a matrix M by randomly changing a subset of matrix entries from ( W bmi )
⊤ such that sim( M , ( W bmi ) ⊤ ) =
α .
Networks trained with SL were able to consistently learn the task with four targets for α > 0 .
Throughout this study, analyses were only performed on networks that successfully learned the center-out reach task.
When calculating the flow field metric in (7), “early” (before learning) and “late” (after learning) blocks consisted of 500 trials.
Activity during learning was split into training trials and test trials; predictions of the (direction of) weight change ∆ W pred | SL and ∆ W pred | RL were constructed using activity h n,t and error ϵ n,t from the training trails, and the full metric Corr(∆ F obs ( h ) , ∆ F pred ( h )) was evaluated on activity h n,t from the test trials.
Fig.
S2 shows that the flow field correlation metric successfully distinguishes the learning rules across hyperparameters, including recurrent noise σ 2rec and number of recurrent units, for both SL and RL.
For networks with a large number of recurrent units, we found that the RL node perturbation algorithm was more effective when the noise was low-dimensional.
In Fig.
S2D, therefore, the recurrent noise is 50-dimensional, and isotropic within those dimensions.
For Fig.
3A, weight mirroring [6] was used as a convenient way to update M while also learning recurrent weights W rec with SL.
Network parameters were the same as Fig. 2, except that η rec was lowered to 0.05 and the weight mirroring learning rate was η WM = 0 .
The weight mirroring algorithm applied to our context simply correlates presynaptic recurrent noise ξ j ∼ N (0 , σ 2rec ) with postsynaptic activity
y i
= W bmi ij ξ j and then updates M with a update rule ∆ M ji = η WM ξ j y i .
On average, this pushes M in the direction of E [ ξ j y i ]
= σ 2rec W bmi ji , i.e. the transpose of the decoder weights W bmi .
For Fig.
3C-E, we included driving feedback weights W fb = γ M and varied the strength of the driving feedback weights by a scalar factor γ between 0.5 and 5.
For these simulations, M was kept fixed at sim( M , ( W bmi ) ⊤ ) = 0 .
Training ran for 5,000 trials for networks using SL, and 10, trials for networks using RL.
Network parameters were the same as Fig.
2, except with η rec = 0 .and
σ 2rec = 0 . 1 .
For Fig.
4, the stimulus signal was equal to 1 for the full trial, and the feedback weights were set to
W fb = γ M with γ = 5 .
Pretraining lasted for 2,500 trials, while training was set to 1,000 trials and the overlap between M and W bmi0 was set to 0.5.
Network parameters were the same as Fig.
2, except with η rec = 1 , and σ 2rec = 0 .
For Fig.
5, we trained networks to learn a cursor-control task with non-isotropic noise via either
SL or RL.
In the SL case, we chose a biased credit mapping M that has partial overlap with the new decoder, with sim( M , ( W bmi1 ) ⊤ ) = 0 .
Network parameters were the same as Fig.
2, except with η rec = 0 .
Training was run for 1,000 trials.
The recurrent noise covariance was chosen to be d -dimensional, with rank( Σ ) =
d , and isotropic within those dimensions.
Simulations were run for d = 5 , 10 , 25 , 50 with three seeds for each dimension.
The first two of these dimensions were selected to lie in the subspace spanned by M for the SL-trained RNNs or by W bmi1 for the
RL-trained RNNs via QR decomposition.
Other components of Σ were added in random dimensions orthogonal to this subspace and to one another.
[Figure]
In Fig.
S1, the network size was 20-20-
[Figure]
and the task was to map T = 5 random binary input patterns onto random output targets.
For SL, the parameters were η SL = 0 .
001 , σ = 0 .
1 , N trials = 500 , and
N early =
N late = 10 .
For RL, the parameters were η SL = 0 .
003 , σ = 0 .
1 , N trials = 5000 , and
N early =
N late = 100 .
In both cases, the results shown in Fig.
S1C,F were computed by averaging over 100 different networks for each condition.
C.2 Alternative supervised learning rules: “Biased” Backpropagation Through Time (BPTT)
As described in the main text, RFLO [5] is an approximate gradient-based algorithm with ∆ W rec ≈ − ∂L/∂ W rec .
The main results of this study depend on the key idea that the matrix M used in the (supervised) learning rule is not identical to the transpose of the decoder weights ( W bmi ) ⊤ .
This idea can be applied to BPTT, leading to a learning rule we call “biased” BPTT.
The standard BPTT update is
[Equation]
with u ti = (cid:80) k W rec ik h t − 1 k + (cid:80) k W in ik x tk
+ (cid:80)
k
W
fb
ik y tk , as in the main text.
For a careful comparison of BPTT, RFLO, and other related gradient-based algorithms for training RNNs, see Refs.
A biased BPTT learning rule according to our framework would simply replace the ( W bmi )
⊤ ϵ t term with M ϵ t :
[Figure]
Train with Biased BPTT
RL
[Figure]
[Equation]
We show in Fig.
S3 that our results hold when using a biased BPTT learning rule instead of the supervised RFLO learning rule.
Network parameters and simulation details were the same as Fig. 2, except that a biased BPTT learning rule was used.
For lower similarity between M and ( W bmi ) ⊤ , the correlation metric is able to correctly identify bias in the change in flow field.
Compared with the results shown in Fig. 2, the correlation metric values are somewhat lower for biased BPTT.
This is likely because additional nonlocal recurrent terms are contained in the true weight update that are not accounted for in the expression for ∆ F predSL that uses ∆ W pred | SL from (5).
[Figure]
C.3 Linear RNNs
We show that the RNN nonlinearity ϕ ( · ) = tanh( · ) is not a crucial architectural choice for our main conclusions.
In Fig.
S4 we apply the same approach (and hyperparameters) as shown in Fig.
2C to linear RNNs and find similar results.
C.4 Velocity-based cursor control
In the main text, we modeled a task in which a BMI readout maps neural activity directly onto cursor position.
While this is a conceptually simple way to illustrate our main ideas, actual BMI experiments more commonly use the readout of neural activity to control cursor velocity rather than position (e.g. Refs.
In this section we show that our main results can also be obtained for this case.
Let the RNN readout y t
= W bmi h t correspond to cursor velocity rather than to cursor position, and let the cursor position be given by r t
= (1 − 1 /τ r ) r t − 1 + y t /τ r .
For simplicity, we take τ r = τ in
RL
SL 0.4 0.5 0.6 0.7 0.8 0.9sim( M , ( W bmi1 ) ) 0.
C o rr ( F ob s ,
F p r ed )
Train with SL A
B
C
SL( M )
RL 0.
sim( M , ( W bmi1 ) ) 0.
C o rr ( F ob s ,
F p r ed )
Train with RL our simulations.
Let the target velocity at time t be given by y ∗ t = r ∗ − r t , where r ∗ is the target position, and the error be given by ϵ t
= y ∗ t − y t .
Using velocity-based cursor control leads to smoother cursor trajectories, as shown in Fig.
S5A.
Figures S5B-C show that the learning rules can be correctly identified in RNNs that are trained under these assumptions using either SL or RL.
[Figure]
C.5 Learning with a BMI that samples from a subset of the neural population
The simulations in this study have assumed that the decoder W bmi reads out the neural activity from all the neurons in the RNN.
While this assumption is not realistic with respect to neuroscience experiments, we show here that it does not affect our conclusions.
We ran simulations for RNNs with 200 recurrent units using SL and varied the number of units read out by the decoder between 25 and 200, setting the decoder weights of all non-readout units to zero.
After pretraining the RNN, the decoder W bmi1 was randomly selected such that sim( W bmi0 , W bmi1 ) = 0 .
5 , while reading out from the same units that were read out from during pretraining.
The credit assignment mapping M was randomly chosen such that sim( M , ( W bmi1 ) ⊤ )
= 0 .
5 , and was not necessarily restricted to the same subset of readout units.
This was repeated with different numbers of readout units, each across 5 random seeds.
Network and training hyperparameters were otherwise the same as in Figures 2 and S2.
Fig.
S6 shows that, in this more realistic scenario where a BMI only decodes a subset of the neurons in the neural population, our correlation metric continues to distinguish between the SL and RL training algorithms.
C.6 Weight updates are distinct for biased SL and RL
In order to build an intuition for how the SL and RL rules affect weight updates, we analyzed these updates directly (rather than the changes in flow fields, which was the focus in the main text).
[Figure]
C
[Figure] [Figure]
SL
[Figure] [Figure]
C o rr(
W ob s ,
W p r ed )
Train with RL
RL 0.
r e w a r d
[Figure]
e x p l a
i ned v a r i
an c e
[Figure]
[Equation]
In the RL case we use (6):
[Equation]
with isotropic noise Σ = σ 2rec I .
Fig.
S7B shows that, for an RNN trained with SL, the observed weight updates ∆ W obs for each trial are highly correlated with the predicted weight updates ∆ W pred | SL .
This is particularly pronounced early in learning, as the loss is still decreasing.
This analysis is applied to a network trained with SL with sim( M , ( W bmi ) ⊤ ) = 0 .
6 , and is one way of building intuition for the results in Fig.
2C and the
FFCC metric Corr(∆ F obs , ∆ F pred ) .
The RL updates look quite different.
Principal component analysis on the weight changes for a network trained with RL shows that weight updates are much more spread out across PCs (Fig.
S7A), which also indicates that individual weight updates don’t follow one direction in the loss landscape.
In
Fig.
S7C, however, the average of the observed weight updates over trials during learning ⟨ ∆ W obs ⟩ is correlated with ∆ W pred | RL predicted after each trial throughout learning.
C.7 Statistical significance of simulations
To confirm the statistical significance of our results and their dependence on the level of noise in the
RNN, we repeat the simulations from Figure 2 with different levels of noise in Figure S8 and show that predictions of the two learning rules are statistically distinct when the alignment between the
BMI decoder and the credit assignment weights is sufficiently small.
C.8 Change of neural activity manifold with training
In order to predict the flow field change for a point h in neural activity space, the direction of weight change is predicted via (5) and (6) by sampling activity from trials during training.
In order to verify that there is significant overlap of the distributions from which h is sampled at different points during training and retraining, we compared the covariance matrices of the RNN activity (Figure S9A) from early trials vs. later trials with the same decoder (Figure S9B, green curve) or trials after retraining on a new decoder (Figure S9B, magenta curve).
These results show that, although the alignment between the neural activity manifolds before vs. after retraining with a new decoder decreases as the old and new decoders become less similar, a significant degree of overlap remains even when the decoders are highly dissimilar.
[Figure]
Train with SL, σ 2 =0.
RL
SL
[Figure] [Figure]
0.5 0.6 0.7 0.8 0.9sim( M , ( W bmi1 ) ) 0.
C o rr ( F ob s ,
F p r ed )
Train with SL, σ 2 =0.
RL
SL *** *** *** ** **
[Figure]
rec
[Figure] [Figure]