Locally Weighted Regression PseudoRehearsal for Online Learning of Vehicle Dynamics
Abstract
We consider the problem of online adaptation of a neural network designed to represent vehicle dynamics. The neural network model is intended to be used by an MPC control law to autonomously control the vehicle. This problem is challenging because both the input and target distributions are nonstationary, and naive approaches to online adaptation result in catastrophic forgetting, which can in turn lead to controller failures. We present a novel online learning method, which combines the pseudorehearsal method with locally weighted projection regression. We demonstrate the effectiveness of the resulting Locally Weighted Projection Regression PseudoRehearsal (LWPR) method in simulation and on a large real world dataset collected with a 1/5 scale autonomous vehicle.
I Introduction
Autonomous vehicles operating in the real world must be capable of precise control in order to satisfy safety constraints and ensure comfort. This, in turn, requires highly accurate dynamics models which can be difficult to obtain. One of the most promising approaches is to learn the dynamics using function approximation methods. However, a major challenge is that the system dynamics are constantly changing, either due to environmental factors (e.g. the road surface condition), or due to internal factors that are hard to measure (e.g. weight distribution, suspension stiffness, steering slop). Therefore, models which are able to adapt to changing dynamics online are necessary.
In this work we examine the use of a neural network to model the system dynamics. Neural networks have recently been demonstrated to be effective at learning system models that can be used in high performance vehicle controllers [27], and are seeing increasing usage in the robotics control literature [16, 11, 4, 3]. Unfortunately, adapting neural networks online is a notoriously difficult problem. The key issue that must be overcome is catastrophic forgetting [13, 17], which is the tendency for neural networks to forget old data when fed new data from a different distribution. This is especially problematic in the case of robotics control, where catastrophic forgetting in the system model can lead to a controller failure.
In order to overcome the catastrophic forgetting problem in neural networks, we make use of a class of modeling techniques which are naturally immune to catastrophic forgetting: locally weighted linear regression [1]. Locally weighted linear regression methods work by building a global model up from a set of many small local linear models. Each model is equipped with a receptive field, which determines how much the model should respond to a given input. The output of the global model is then computed as a weighted average of all the local model outputs [22, 24]. Since a given training pair only affects a highly localized region of the state space, locally weighted regression methods can safely make incremental updates. One of the most mature local modelling methods is locally weighted projection regression (LWPR) [24]. LWPR has proven successful in modeling robot dynamics, even for highdimensional systems in an online learning scenario.
Given the success of LWPR at the task of learning robot dynamics, and the ability for it to be used in an incremental online setting, one may wonder: why not use LWPR instead of neural networks for learning system dynamics? The issue with utilizing locally linear methods in model predictive control is the computational cost. In the past, locally weighted regression methods have been limited to inverse control, which only requires a single prediction per timestep, or offline trajectory/policy optimization [1, 15]. In cases where they have been used in MPC [26], the model had to be severely restrained in order to control the number of local models generated. The issue is that for local linear methods to achieve high accuracy, usually thousands or even tens of thousands of local models are required to be effective. This requires an order of magnitude more floating point operations than a neural network to get comparable prediction accuracy. Thus, utilizing locally linear methods instead of neural networks inside of an MPC method would come at a significant opportunity cost, if it were even possible to run in realtime.
Instead of directly utilizing LWPR in the MPC controller, our approach will be to maintain both a neural network model and an LWPR model. The neural network model is used by an MPC controller and it is updated online using data recently collected from the system, but it is also regularized using pseudosamples generated by an LWPR model. The LWPR model is updated in an incremental online manner, in order to ensure that the artificially generated data matches the current target distribution.
Ii Related Work on Neural Network Adaptation
Some of the earliest methods proposed for mitigating catastrophic forgetting in neural networks are rehearsal and pseudorehearsal [17, 19, 20, 21, 5]. In rehearsal methods, the original training data is retained and used alongside the new data in order to update the model. Pseudorehearsal methods do not retain old data, but instead they randomly create input vectors (pseudoinputs) that are then fed through the current network in order to produce a corresponding output point (pseudooutput). The resulting artificially generated sample (pseudosample) can then be used for training the network alongside newly received data. The idea is that, by using the pseudosamples alongside real data, the network can be encouraged to learn the new data without forgetting the current mapping. Recently, there has been success using rehearsal [18] and pseudorehearsal based methods for vision tasks [23, 2, 14, 7]. In these methods the primary challenge that must be overcome is either storing previous data samples (in rehearsal methods) or randomly generating realistic inputs (for pseudorehearsal methods).
In the case of learning vehicle dynamics, generating pseudoinputs is relatively easy due to the low dimensional statespace representation of a vehicle. Instead, there is another challenge that must be overcome that cannot be handled by the usual rehearsal or pseudorehearsal techniques: both the input and target distributions are nonstationary. This means that sometimes we need to learn new data while retaining old data, which is the case when encountering a novel region of the state space. But, other times, we need to learn new data which overwrites old data, this is the case if we are in a familiar region of the statespace but the target distribution has changed. The approach we develop to handle this problem is best thought of as a type of pseudorehearsal method, with the key innovation being the use of an incrementally updated LWPR model to produce the pseudooutputs. We also make use of a constrained gradient descent update rule in order to prevent large errors on new training data from overwhelming the training signal on previously seen data.
Besides rehearsal and pseudorehearsal methods, there are a variety of methods for updating neural networks which mitigate catastrophic forgetting by controlling how far the parameters of the model can move away from the current model. For instance, this is the approach taken in [25, 9, 12]. However, as in the case of rehearsal and pseudorehearsal, it is not clear how controlling changes in the weights works when the target distribution is variable, since in that case the network weights corresponding to previously learned data will need to be changed as well. Another promising approach to online adaptation for neural networks that has recently been explored is metalearning [3]. However the metalearning approach does not have an explicit mechanism to combat catastrophic forgetting, and it is currently unclear how to perform the metatraining in order to ensure that catastrophic forgetting cannot occur.
Iii Problem Formulation
Consider an autonomous vehicle operating at some task, while performing the task the vehicle encounters system states, denoted , and executes controls, denoted . Our goal is to update the model of the vehicle dynamics, which is defined using the following discrete time dynamical system:
(1) 
Where denotes the parameters of the model, in our case these are the weights of a neural network. The system states for the vehicle are position, heading, roll, velocities, and heading rate, and the control inputs are steering and throttle commands. In the case of a ground vehicle, the position and heading updates are kinematically trivial, so we can rewrite the dynamics as:
(2)  
(3) 
Here denotes kinematic states, which are position and heading, and denotes dynamics states, which are roll, bodyframe longitudinal and lateral velocity, and heading rate. The motion update for the kinematic states is trivial, so we need only focus on learning . Now, we define the following variables:
(4) 
as the inputs and targets for our learning algorithm. Now, as the vehicle moves about in the world, it encounters states and controls according to some probability distribution:
(5) 
The distribution is called the local operating distribution, and it is highly task dependent. In addition to the local operating distribution, we assume that there is a system identification dataset, which contains data consisting of all the various maneuvers that the vehicle needs to learn in order drive competently. The system identification dataset consists of samples drawn from another distribution:
(6) 
which we denote as , and refer to as the system identification distribution. Note that this distribution is constant, but the mapping which takes input points drawn from this distribution to the corresponding dynamics output is not. Our goal is to incrementally update a neural network describing the system dynamics. However, we must be sure that by updating the model we do not forget any of the system modes contained in .
First consider a simple approach to performing online model adaptation based on standard stochastic gradient descent (SGD). Suppose that we have access to streaming data, and that we maintain a set of recently encountered input and output pairs. By randomly drawing pairs from this set, we can get independent and identically distributed (I.I.D.) samples from the local operating distribution. The standard SGD rule updates the parameters as follows:
(7) 
since training pairs are drawn from the local operating distribution, this update will improve the model’s performance for the inputs drawn from that distribution. Mathematically, this means that we are optimizing for the objective:
(8) 
This is not what we want. The issue with this is that the local operating distribution may not contain all the maneuvers that the vehicle needs to operate effectively. A typical example in the case of autonomous driving is highway driving: a vehicle operating on a highway only needs to maintain a constant velocity and make slight turns the vast majority of the time, if the model is updated with inputs purely drawn from a highway driving dataset, there is no guarantee that the model will remember the basic maneuvers necessary for other types of driving. This problem, known as catastrophic forgetting, is a well known deficiency of neural networks, and it is especially problematic when the model being updated is being used to control the vehicle.
If we had access to I.I.D. samples from the system identification dataset, we could instead use an SGD update law that jointly learns the target mapping for inputs drawn both from the system identification dataset and the local operating distribution. For instance, the following update law achieves this:
(9)  
(10)  
(11)  
(12) 
This update balances optimizing the model on the local operating distribution and the system identification dataset, and it is the basic idea behind traditional rehearsal and pseudorehearsal techniques. In the case of classification, this type of update is effective at preventing catastrophic forgetting. But, in the regression setting, even this type of update could be problematic since the magnitude of the error incurred by the network can vary greatly depending on the region of statespace the system is in. If the error incurred by the local operating distribution is very high it can overwhelm the error signal from the system identification part of the data, which can still lead to the vehicle forgetting basic maneuvers.
Instead, we want to ensure that the model cannot forget the system identification dataset, in this context “forgetting” means intentionally degrading the performance of the model on input data drawn from . One way to enforce that is to ensure that update steps always move in the direction of the local minima for input data drawn from the system identification distribution. This constraint can be enforced by ensuring that the cosine of the angle between the update direction and the gradient computed from the system identification data is always positive, and it can be achieved with the following update law:
(13)  
(14) 
This update law still balances the objective of simultaneously optimizing for local operating distribution and system identification distribution. However, it constrains the combined gradient to always point in the same direction as the gradient computed from system identification data.
The problem with implementing the update rule defined by Eq. (13) is that, in an online setting, we only have access to data generated from the local operating distribution. Additionally, since the target mapping is changing, we cannot simply redraw samples from the original system identification dataset or generate pseudooutputs by running random inputs through the current model like in standard rehearsal and pseudorehearsal methods.
Iv Locally Weighted Projection Regression PseudoRehearsal
Our goal is to approximately implement the constrained gradient update defined in Eq. (13). Our strategy will be to use artificially generated pseudotraining points to enforce the constraint, with the additional requirement that the pseudotraining points must somehow match the changing target distribution. This means that artificially generating training points requires two steps:

A method for generating artificial input points that are I.I.D. samples from .

A method for computing the corresponding target, , for an artificially generated input point. This should be a function approximator that is capable of online adaptation, since the target mapping is actively changing.
Given these requirements, it appears as though we cannot go anywhere, since the preceding discussion can roughly be summarized as: in order to perform online adaptation we first need a method that can do online adaptation in order to constrain the stochastic gradient descent update. The reason why this is not the case, is that the speed requirements on the model used for artificial data generation are much less strenuous than the speed requirements for a model used in model predictive control.
Suppose that we are receiving inputs points at a rate of 40 Hz, a reasonable number for a robotic system, then in order to produce an equal number of artificial points for regularization our model needs to be able to produce 40 predictions/second. In contrast, for our sampling based MPC controller we require the model to produce on the order of millions of predictions per second. Even less computationally intensive MPC algorithms (iLQG for instance) require on the order of tens of thousands of predictions (plus derivative computations) per second. So, even for relatively inexpensive MPC algorithms the computational demands on the model used for artificial data generation are 3 orders of magnitude less than the model used for MPC, and 5 orders of magnitude less than for our sampling based controller. This means that we can use more computationally demanding models that are specifically suited to online adaptation in order to generate the artificial data, such as LWPR.
Iva Algorithm Description
Our approach will be to train an LWPR model, which will be updated online, in order to compute the target mapping for artificially generated input points. For the generation of the input points, a gaussian mixture model (GMM) is used. The GMM is trained offline and kept static, which reflects the fact that the input distribution defined by the system identification dataset does not change. The artificial input/output pairs are then used to compute a synthetic gradient, which is used to regularize the online stochastic gradient descent. The algorithm consists of four submodules, which we now describe in detail. The overall flow of the algorithm is shown in Fig. 1.
IvA1 Gaussian Mixture Model
The purpose of the GMM is to generate synthetic input points consistent with the system identification dataset. We denote a minibatch of synthetic input points as . The GMM uses diagonal covariance matrices, and is trained using standard expectation maximization. We use the Bayesian Information Criterion (BIC) in order select the number of gaussian models used. After the initial training the GMM is not modified again. This is because the input distribution for the system identification dataset should be carefully curated in order to ensure that it contains a balance of all necessary maneuvers.
IvA2 LWPR Module
The LWPR module takes in the synthetic input points generated by the Gaussian mixture model, and then runs those input points forward through the LWPR model in order to produce synthetic output points. If we let and be the mean and center of the local model and let be the distance metric which defines the receptive field for the model, then LWPR computes the global prediction as:
(15) 
Where the weight governing the response of each local model is:
(16) 
Since the response of a given model to an input decays exponentially fast, model updates have only a negligible impact on models with centers far from the current input point. This is the feature that makes LWPR largely immune to catastrophic forgetting, so it can be safely updated online.
The minibatch output of the LWPR module is denoted . The LWPR model is initially trained over several epochs on the system identification dataset using the standard LWPR update rule. Online, the local linear models making up the LWPR model are continually updated. We train one LWPR model for each different output dimension (roll rate, longitudenal acceleration, lateral acceleration, and heading acceleration). The LWPR module is implemented using [10].
IvA3 Local Operating Set
The local operating set consists of the last several seconds of training points received from the stream of data generated by the system. In our implementation this set contains between 500 and 1000 (10  20 seconds) of data. Out of this set of data, randomized minibatches are created (denoted as ) and then fed into the model updater.
IvA4 Model Update
The last module in the LWPR algorithm is the computation of the constrained gradient and the actual model update. First, the gradient for the local operating distribution, , is computed using the minibatch received from the local operating distribution, and then the gradient for the system identification dataset, is computed using the artificial minibatch received from the GMM and LWPR modules. The constrained gradient is computed via equations (9)  (13). After the gradient is computed we use the ADAM optimizer [8] to perform the update step.
IvB Neural Network Initialization
Before the neural network can be updated, an initial model needs to be trained on the original system identification dataset. One option is to initialize the model using standard stochastic gradient descent (i.e. without taking into account the other modules), but we have found it is more effective to jointly train the initial model with the LWPR model and GMM model. This means that the actual system identification dataset takes the place of the local operating set, but synthetic data is still generated by the GMM and LWPR modules, which is used to compute the constrained gradient. We have observed that training the initial model in this manner has a negligible effect on the performance of the initial trained model, but helps with the adaptation.
V Results
We tested our locally weighted projection regression pseudorehearsal (LWPR) approach using four different sets of experiments. All of the data in these experiments are collected using vehicles based on the design from [6] or the simulation tools from [6]. These vehicles are called “AutoRally” platforms, and they are highly robust 1/5 scale autonomous vehicles which have realistic dynamics compared to a full size platform.
Our first experiment tests the algorithm’s ability to prevent catastrophic forgetting, using a dataset designed specifically to induce catastrophic forgetting on naive adaptation methods. The second experiment tests the method’s ability to adapt to drastic changes in the system dynamics using a driving dataset collected on a muddy surface. The third experiment tests how effective the updated model is when used as part of an MPC algorithm. Lastly, the fourth experiment consists of running the model adaptation during a full day of testing with the 1/5 scale autonomous driving system, and measures how well the algorithm works in a practical setting. Throughout these experiments there are 3 different types of experimental modes that are run:

An offline test is a test where the model is not allowed to adapt during the experiment.

An online test is a test where the model is allowed to adapt during the experiment, but the adapted model is not used to control the vehicle.

An active test is a test where the model is allowed to adapt during the experiment, and the adapted model is used to control the vehicle.
Recall that in an online training scenario, there is not an explicit training, validation, and test set. Instead, as each training pair is received, we compute the current error on that training pair, and we then record the result. After the error has been computed and recorded, the training pair is fed into the model updater. We compare our method against the base model (no adaptation), and the base model adapted with standard stochastic gradient descent. We also record the performance of the LWPR model used to generate synthetic training inputs.
It is important to realize that the LWPR model we use for generating synthetic data would not be feasible for use in a realtime control loop. Tables I and II detail the computational requirements of the neural network and LWPR respectively. For these calculations, we assume that a dot product operation takes floating point operations (FLOPs) for vectors of dimension , and that a matrixvector multiplication takes FLOPs where the matrix has dimension . We also assume that any nonlinear function () takes a FLOP. For LWPR it can be difficult to predict the throughput required since the number of active local models can vary greatly, so we compute a lower bound based only on how many local model activations must be computed. Computing a local model activation requires first subtracting the mean for the local model from the current input point ( FLOPs), then individually squaring each result ( FLOPs), then computing the dot product between the result and the receptive field weight ( FLOPs), and then computing the negative exponential of the result ( FLOPs). This results in a total of 25 floating point operations for each local model, plus the additional computations required to actually compute the weighted average. The neural network simply consists of matrixvector multiplies, the additions of the bias, and nonlinearities. Note also, that LWPR works best when a separate model is used for each output dimension, whereas only one neural network is required.
Output Variable  Receptive Fields  FLOPs/Pred 

Roll Rate  
Longitudinal Acc.  
Lateral Acc.  
Heading Acc.  
Total 
Layer Transition  Input  Output Neurons  FLOPs/Pred 

Input  Hidden 1  6  32  416 
Hidden 1  Hidden 2  32 32  2,080 
Hidden 2  Output  32  4  256 
Total  632324  2,688 
The key takeaway from Tables I and II is that making predictions with the neural network is two orders of magnitude cheaper than making predictions with LWPR models. Since MPC controllers need to make tens of thousands or millions of predictions per second, this is important. For instance, our MPC controller performs 6 million dynamics predictions every second. If we used the LWPR model that we have trained we would need to achieve a throughput of at least 847 GFLOP/S to run in real time. Although this number is technically achievable for modern graphics cards on dense matrix multiplication benchmarks (the Nvidia GTX 1050 Ti in our AutoRally platform has a peak measured performance of 1.8 TFLOPS), it is not currently possible for algorithms with more complicated memory usage, control flow and synchronization requirements  such as forward propagating an LWPR model. In contrast, the synthetic data generation only requires on the order of tens or hundreds of predictions per second, which is easily manageable on any reasonably capable modern processor.
Va Catastrophic Interference Test
In this experiment we test the ability of LWPR to improve online modeling performance while simultaneously “remembering” other parts of the system identification dataset. These experiments utilize two datasets, which we selected from the publicly available dataset accompanying [27]. The first dataset we call the online training dataset and the second is called the offline validation dataset. These datasets were collected on the same day, so the environmental differences are minimal^{1}^{1}1The offline validation dataset was collected approximately 30 minutes before the online training dataset. The online training dataset consists of 100 laps (approximately 27 minutes) of slow speed driving around a roughly elliptical track in the clockwise direction. This is an extremely monotonous dataset, as the robot mostly follows the same line over the 100 laps.
Given the monotonous nature of the online training dataset, it is easy for the online adaptation to overfit to the local operating distribution and forget parts of the system identification dataset. In order to test how well the model adaptation is able to remember other system modes, we utilize the offline validation dataset. The offline validation dataset consists of the same type of low speed monotonous driving in the opposite (counterclockwise) direction of the online training dataset. If the model adaptation algorithm is successful at remembering the system identification dataset, then we should be able to run the adaptation on the online training dataset and see minimal degradation when testing the final adapted model on the offline validation dataset.
Base  SGD  LWPR  LWPR  
Roll Rate ()  0.01  0.01  0.01  0.01 
Longitudinal Acc.  0.35  0.33  0.32  0.33 
Lateral Acc.  0.69  0.63  0.61  0.65 
Heading Acc.  2.11  0.46  0.49  0.53 
Total MSE  0.79  0.36  0.36  0.38 
Base  SGD  LWPR  LWPR  
Roll Rate ()  0.01  0.01  0.01  0.00 
Longitudinal Acc.  0.20  0.22  0.20  0.17 
Lateral Acc.  0.99  1.56  1.10  0.83 
Heading Acc.  1.47  2.11  0.83  0.42 
Total MSE  0.67  0.97  0.53  0.36 
The testing procedure works as follows: we first test the online performance of each of the methods using the online training dataset. Then, after the online test is finished, the final adapted model is taken and an offline test (no adaptation allowed) is performed on the offline validation dataset. The results of these tests are shown in Tables III and IV.
For the online training dataset all of the adaptive methods perform similarly, and they all significantly decrease the total meansquared error of the model predictions compared with the base neural network model. However, when using the final adapted model from the online training dataset on the offline validation dataset, the differences between the methods become apparent. The standard SGD methods suffers the characteristic catastrophic forgetting, particularly in the heading acceleration which makes sense given the difference in the direction of travel between the two datasets. As expected, LWPR is unaffected by the change in local operating distribution, and performs better than the base network. Our LWPR method performs only slightly worse than LWPR and outperforms the base network. This shows that the method is not only capable of preventing catastrophic forgetting, but that it is actually able to generalize knowledge gained in one dynamics regime to another related dynamics regime.
VB Modified Dynamics Test
In this experiment we test the ability of the algorithm to adapt to highly modified vehicle dynamics. The dynamics are modified by running the vehicle on a muddy track surface. The mud changes the dynamics because it clings to the tires and reduces the friction between the vehicle and the ground. Additionally, the mud clinging to the body of the vehicle adds over 10 kg of extra weight (the normal weight is 21 kg), which has a significant effect on the vehicle’s dynamics. All of the system identification data was collected on a dry surface with a mud free robot, so this is a completely novel dynamics regime for the system.
The vehicle is driven by an expert 1/5 scale RC car driver in the muddy conditions. Despite the poor driving conditions, the driver is still able to attain speeds over 50 kph and slip angles in excess of 60 degrees. This means that the dataset is challenging not only because of the changing conditions, but also because of the highly dynamic regime that the vehicle operates in. This dataset consists of slightly more than 2.5 minutes of data, which is 5 laps around our test track. The results are given in Table V.
Base  SGD  LWPR  LWPR  
Roll Rate ()  0.02  0.02  0.02  0.02 
Longitudinal Acc.  2.42  1.52  1.60  1.70 
Lateral Acc.  1.04  1.02  0.96  0.98 
Heading Acc.  4.96  2.64  2.74  3.10 
Total MSE  2.11  1.29  1.33  1.45 
All of the incremental methods achieve a better total MSE than the unmodified base network. The LWPR method actually outperforms LWPR by a significant margin. The standard SGD method performs best, as it did in the catastrophic forgetting test on the online training dataset. The weakness of SGD is not that it does not fit the local operating distribution, but that it can easily forget the system identification dataset.
VC Simulated Autonomous Driving Tests
The previous two experiments tested our method on datasets where the model being produced by the model adaptation was not being used to control the vehicle. In this section, we test the algorithm in an active setting where a model predictive controller uses the updated model to control the vehicle. We use the same open source Gazebo simulation of the AutoRally vehicle from [6] for these experiments. The system identification dataset that we use to train the base model is the same as in the previous sections (i.e. it is based on real world data). Note that the simulation dynamics are significantly different from the realworld AutoRally dynamics, so the starting base model is highly inaccurate.
We ran three different model adaptation settings: standard SGD, LWPR, and no adaptation. For each setting we performed trials running 10 laps around the track, and we collected 5 trials for each different setting. The vehicle is driven using the model predictive path integral controller from [27], with a desired speed set^{2}^{2}2For speeds higher than the accelerations reported by the simulator exhibited high frequency oscillations indicating numerical instability of the simulator, this prevented us from trying faster speeds using the model adaptation. at . In order to emphasize the impact of the model adaptation, we set the maximum slip angle the vehicle is allowed to achieve to be relatively low ( degrees). Since the vehicle slides less easily in the gazebo simulation than in the real world, this results in a very conservative controller when using the base model (which has only seen realworld data). As the model adapts, the controller should realize that it can increase speed without slipping, leading to improved performance.
The results of all of the trials are shown in Table VI. Using either the base model or the LWPR adapted model, the controller is able to successfully navigate around the track. However, when using standard SGD to update the model the controller consistently fails after completing 1 lap, typically the controller tries to take a turn too fast, which results in the vehicle rolling over.
Base Network  SGD  LWPR  

Avg. Laps Completed  10  1  10 
Avg. Trial MSE  1.84  2.49  0.65 
Avg. Lap Time  34.78  N/A  32.04 
Trajectory traces for the base model and LWPR are shown in Fig. 3. The base model performs adequately, and the controller is able to consistently drive the vehicle around the track using the base model. However, the controller with the updated LWPR model is able to attain a higher average velocity around the track.
Figure 4 shows the progression of lap times and total MSE per lap as each trial progresses. On average, it takes less than one lap for the MPC controller to start benefiting from the model adaptation: as the model adapts it realizes it can go faster without slipping in the simulation than it can in the real world and the result is a performance increase. The performance on the second lap is significantly better with the LWPR adapted model than with the base model. After the second lap, the model continues to make small improvements in the per lap MSE.
VD AutoRally Experimental Results
In the previous sections we tested our model adaptation approach in three essential areas: robustness to catastrophic interference, ability to adapt to drastic changes in the dynamics, and effectiveness when utilized by an MPC controller. These experiments were conducted in a controlled manner using either simulation or specially collected datasets. In this section, we examine how the model adaptation scheme works in a more natural environment  the model adaptation is turned on at the beginning of a day of testing and allowed to run uninterrupted^{3}^{3}3Technically the actual program running the model adaptation is interrupted when there are long pauses in testing. However it saves the current parameters, and reloads them when testing resumes. for the entire day. The resulting dataset consists of over 1 hour of autonomous data collected over a period of 4.5 hours. The 1 hour of autonomous data consists of approximately 18 kilometers of driving data with speeds up to 50 kph. Note that this dataset contains a significant amount of natural variation: the early morning runs are with a fresh damp track, whereas test runs in the afternoon are with a drier track that has less grip. Many of the tests start when the vehicle has a fully charged battery, and then end with a dead battery, and then are continued with another fully charged battery, this means that the adaptation has to constantly relearn similar parts of the dynamics over again. The tires also become gradually worn out, which has a significant effect on the friction available.
For this dataset we record the same performance metrics as in the earlier online dataset experiments for each of the four adaptation strategies. Additionally, we have available the active performance of LWPR data since the model produced by LWPR was being used to drive the vehicle autonomously. For the active version of LWPR we used a slightly more conservative learning rate, which explains the performance difference between the active and nonactive LWPRSGD algorithms. Note that the errors produced by the vehicle running autonomously in these experiments are on average higher than the errors reported in the previous sections. This is due to a combination of speed and control style: moving faster produces higher accelerations which lead to higher errors than in the catastrophic forgetting test, and the autonomous control system does not produce as smooth of control inputs as the expert human which can also lead to high accelerations relative to the expert.
The results over the full day of testing are given in Table VII. Once again, all of the incremental method significantly improve the performance from the base model. The SGD and LWPR methods perform nearly identically on the online test, but the method updated with LWPR is able to be safely utilized by an MPC controller.
Base  SGD  LWPR  LWPR  
Roll Rate ()  0.01  0.01  0.01  0.01 
Longitudinal Acc.  2.73  2.28  2.30  2.06 
Lateral Acc.  1.71  1.29  1.24  1.28 
Heading Acc.  8.28  4.48  4.87  4.54 
Total MSE  3.18  2.10  2.11  1.97 
Active Performance (MSE)  N/A  N/A  2.54  N/A 
Vi Conclusion
In this paper we have presented a novel method for pseudorehearsal that is applicable to learning vehicle models in changing environments. The key contributions are:

Using an incrementally updated LWPR model in order to create artificial training pairs. The use of incrementally updated LWPR enables pseudorehearsal to be applied to systems where both the input and target distributions are nonstationary.

Using a constrained gradient update, which ensures that the adaptation cannot move away from the system identification dataset, no matter how large the errors it encounters in other regions of the statespace are.
In order to test our method we created a series of datasets and simulation tests that stressed essential requirements for an online adaptation scheme: the ability to prevent catastrophic forgetting, adapt to drastic changes in the dynamics, and the ability to produce models usable by an MPC controller. These experiments demonstrated the capability of our approach and also highlighted some of the nuances involved in validating online adaptation algorithms: in all of the online experiments the standard SGD method performed at the level of the LWPR and LWPR algorithms, it was not until the SGD method was tested on a specifically collected validation dataset or tried to be combined with an MPC controller, that the deficiencies of the SGD method became apparent. We have also demonstrated the practicality of the approach by performing an extended test of the method, where it is required to run continually for hours at a time while producing models that are capable of high speed driving.
References
 Atkeson et al. [1997] Christopher G Atkeson, Andrew W Moore, and Stefan Schaal. Locally weighted learning for control. In Lazy learning, pages 75–113. Springer, 1997.
 Atkinson et al. [2018] Craig Atkinson, Brendan McCane, Lech Szymanski, and Anthony V. Robins. Pseudorehearsal: Achieving deep reinforcement learning without catastrophic forgetting. CoRR, abs/1812.02464, 2018. URL http://arxiv.org/abs/1812.02464.
 Clavera et al. [2018] Ignasi Clavera, Anusha Nagabandi, Ronald S. Fearing, Pieter Abbeel, Sergey Levine, and Chelsea Finn. Learning to adapt: Metalearning for modelbased control. CoRR, abs/1803.11347, 2018. URL http://arxiv.org/abs/1803.11347.
 Finn and Levine [2017] Chelsea Finn and Sergey Levine. Deep visual foresight for planning robot motion. In International Conference on Robotics and Automation (ICRA), pages 2786–2793. IEEE, 2017. URL https://arxiv.org/pdf/1610.00696.pdf.
 French [1997] Robert M French. Using pseudorecurrent connectionist networks to solve the problem of sequential learning. In Proceedings of the 19th Annual Cognitive Science Society Conference, volume 16, 1997.
 Goldfain et al. [2019] B. Goldfain, P. Drews, C. You, M. Barulic, O. Velev, P. Tsiotras, and J. M. Rehg. Autorally: An open platform for aggressive autonomous driving. IEEE Control Systems Magazine, 39(1):26–55, Feb 2019. URL https://ieeexplore.ieee.org/document/8616931.
 Kemker and Kanan [2017] Ronald Kemker and Christopher Kanan. Fearnet: Braininspired model for incremental learning. CoRR, abs/1711.10563, 2017. URL http://arxiv.org/abs/1711.10563.
 Kingma and Ba [2014] Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2014. URL http://arxiv.org/abs/1412.6980.
 Kirkpatrick et al. [2017] James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka GrabskaBarwinska, et al. Overcoming catastrophic forgetting in neural networks. Proceedings of the national academy of sciences, page 201611835, 2017. URL https://arxiv.org/abs/1612.00796.
 Klanke et al. [2008] Stefan Klanke, Sethu Vijayakumar, and Stefan Schaal. A library for locally weighted projection regression. Journal of Machine Learning Research, 9:623–626, 2008. URL http://www.jmlr.org/papers/v9/klanke08a.html.
 Lenz et al. [2015] Ian Lenz, Ross A Knepper, and Ashutosh Saxena. Deepmpc: Learning deep latent features for model predictive control. In Robotics Science and Systems (RSS), 2015. URL http://www.roboticsproceedings.org/rss11/p12.html.
 Li and Hoiem [2018] Zhizhong Li and Derek Hoiem. Learning without forgetting. Transactions on Pattern Analysis and Machine Intelligence, 40(12):2935–2947, 2018. URL https://arxiv.org/abs/1606.09282.
 McCloskey and Cohen [1989] Michael McCloskey and Neal J Cohen. Catastrophic interference in connectionist networks: The sequential learning problem. In Psychology of learning and motivation, volume 24, pages 109–165. Elsevier, 1989.
 Mellado et al. [2017] Diego Mellado, Carolina Saavedra, Stéren Chabert, and Rodrigo Salas. Pseudorehearsal approach for incremental learning of deep convolutional neural networks. In Latin American Workshop on Computational Neuroscience, pages 118–126. Springer, 2017. URL https://link.springer.com/chapter/10.1007/9783319710112_10.
 Mitrovic et al. [2008] Djordje Mitrovic, Stefan Klanke, and Sethu Vijayakumar. Adaptive optimal control for redundantly actuated arms. In International Conference on Simulation of Adaptive Behavior, pages 93–102. Springer, 2008. URL https://link.springer.com/chapter/10.1007/9783540691341_10.
 Nagabandi et al. [2018] Anusha Nagabandi, Gregory Kahn, Ronald S Fearing, and Sergey Levine. Neural network dynamics for modelbased deep reinforcement learning with modelfree finetuning. In International Conference on Robotics and Automation (ICRA), pages 7559–7566. IEEE, 2018. URL https://arxiv.org/abs/1708.02596.
 Ratcliff [1990] Roger Ratcliff. Connectionist models of recognition memory: constraints imposed by learning and forgetting functions. Psychological review, 97(2):285, 1990.
 Rebuffi et al. [2017] SylvestreAlvise Rebuffi, Alexander Kolesnikov, Georg Sperl, and Christoph H Lampert. icarl: Incremental classifier and representation learning. In Conference on Computer Vision and Pattern Recognition (CVPR), pages 5533–5542. IEEE, 2017. URL https://arxiv.org/abs/1611.07725.
 Robins [1993] Anthony Robins. Catastrophic forgetting in neural networks: the role of rehearsal mechanisms. In First New Zealand International TwoStream Conference on Artificial Neural Networks and Expert Systems, pages 65–68. IEEE, 1993.
 Robins [1995] Anthony Robins. Catastrophic forgetting, rehearsal and pseudorehearsal. Journal of Neural Computing, Artificial Intelligence and Cognitive Research, 7:123–146, 1995.
 Robins [2004] Anthony Robins. Sequential learning in neural networks: A review and a discussion of pseudorehearsal based methods. Intelligent Data Analysis, 8(3):301–322, 2004.
 Schaal and Atkeson [1998] Stefan Schaal and Christopher G Atkeson. Constructive incremental learning from only local information. Neural computation, 10(8):2047–2084, 1998.
 Shin et al. [2017] Hanul Shin, Jung Kwon Lee, Jaehong Kim, and Jiwon Kim. Continual learning with deep generative replay. In Advances in Neural Information Processing Systems, pages 2990–2999, 2017. URL https://arxiv.org/abs/1705.08690.
 Vijayakumar et al. [2005] Sethu Vijayakumar, Aaron D’souza, and Stefan Schaal. Incremental online learning in high dimensions. Neural computation, 17(12):2602–2634, 2005.
 Wan and Banta [2006] S. Wan and L. E. Banta. Parameter incremental learning algorithm for neural networks. IEEE Transactions on Neural Networks, 17(6):1424–1438, Nov 2006. ISSN 10459227. doi: 10.1109/TNN.2006.880581.
 Williams et al. [2014] Grady Williams, Eric Rombokas, and Tom Daniel. Gpu based path integral control with learned dynamics. In Neural Informations Processing Systems: Autonomously Learning Robots Workshop, 2014. URL https://arxiv.org/abs/1503.00330.
 Williams et al. [2018] Grady Williams, Paul Drews, Brian Goldfain, James M Rehg, and Evangelos A Theodorou. Informationtheoretic model predictive control: Theory and applications to autonomous driving. IEEE Transactions on Robotics, 34(6):1603–1622, 2018. URL https://ieeexplore.ieee.org/document/8558663.