Learning How to Autonomously Race a Car: a Predictive Control Approach

TL;DR

This paper introduces a Learning Model Predictive Controller for autonomous racing that iteratively improves lap times by updating control strategies based on previous laps, reducing computational load and using system identification.

Contribution

It proposes a novel LMPC strategy that minimizes computational complexity and introduces a system identification method for autonomous racing control.

Findings

Reduced computational burden in LMPC

Successful experimental validation on Berkeley Autonomous Race Car

Improved lap times through iterative learning

Abstract

In this paper we present a Learning Model Predictive Controller (LMPC) for autonomous racing. We model the autonomous racing problem as a minimum time iterative control task, where an iteration corresponds to a lap. In the proposed approach at each lap the race time does not increase compared to the previous lap. The system trajectory and input sequence of each lap are stored and used to systematically update the controller for the next lap. The first contribution of the paper is to propose a LMPC strategy which reduces the computational burden associated with existing LMPC strategies. In particular, we show how to construct a safe set and an approximation to the value function, using a subset of the stored data. The second contribution is to present a system identification strategy for the autonomous racing iterative control task. We use data from previous iterations and the vehicle's kinematics equations to build an affine time-varying prediction model. The effectiveness of the proposed strategy is demonstrated by experimental results on the Berkeley Autonomous Race Car (BARC) platform.

Tables

Table 1. TABLE I: Parameters used in the controller design.

$l$	$j-2$
$K$	20
$T$	diag$(0,0,0,0,1,0)$
$Q$	diag$(0.1,1,1,0,0,0)$
$P$	80
$h$	10
$N$	12

Equations

$$x={\left[\begin{array}{c}{v}_x,v_y,w_z,e_{\psi },s,e_y\end{array}\right]}^{\top }\text{ and }u={\left[\begin{array}{c}\delta ,a\end{array}\right]}^{\top },$$

$$x_{t+1}=f(x_t,u_t),$$

$$x_t\in \mathcal{X}=\{x\in {\mathbb{R}}^n:F_{x}x\le b_x\},$$

$$u_t\in \mathcal{U}=\{u\in {\mathbb{R}}^d:F_{u}u\le b_u\},\forall t\ge 0.$$

$$\underset{T,u_0,\dots ,u_{T-1}}{\min }$$

$$x_{t+1}=f(x_t,u_t),$$

$$x_t\in \mathcal{X},u_t\in \mathcal{U},$$

$$x_T={\mathcal{X}}_F,x_0=x_S,$$

$${\mathcal{X}}_F=\{x\in {\mathbb{R}}^n:[000010]x=s\ge L\}$$

$${\mathbf{u}}^j$$

$${\mathbf{x}}^j$$

$$=\underset{t_1,\dots ,t_K}{\mathrm{argmin}}$$

$$t_i\ne t_k,\forall i\ne k$$

$$t_i\in \{0,\dots ,T^j\},\forall i\in \{1,\dots ,K\}.$$

$$D_l^j(x)=[x_{t_1^{l,\ast }}^l,\dots ,x_{t_K^{l,\ast }}^l,\dots ,x_{t_1^{j,\ast }}^j,\dots ,x_{t_K^{j,\ast }}^j],$$

$${\mathcal{CL}}_l^j(x)=\{\bar{x}\in {\mathbb{R}}^n:\exists \mathbf{\lambda }\in$$

$$\mathbf{\lambda }\ge 0,\text{mathds}1\mathbf{\lambda }=1,D_l^j(x)\mathbf{\lambda }=\bar{x}\}.$$

$$S_l^j(x)=[x_{t_1^{l,\ast }+1}^l,\dots ,x_{t_K^{l,\ast }+1}^l,\dots ,x_{t_1^{j,\ast }+1}^j,\dots ,x_{t_K^{j,\ast }+1}^j]$$

$$Q_l^j(\bar{x},x)=\underset{\mathbf{\lambda }}{\min }$$

$$\mathbf{\lambda }\ge 0,\text{mathds}1\mathbf{\lambda }=1,D_l^j(x)\mathbf{\lambda }=\bar{x},$$

$${\mathbf{J}}_l^j(x)=[J_{t_1^{l,\ast }\to T^l}^l$$

$$J_{t_1^{j,\ast }\to T^j}^j(x_{t_1^{j,\ast }}^j),\dots ,J_{t_M^{j,\ast }\to T^j}^j(x_{t_M^{j,\ast }}^j)],$$

$$J_{t\to t+N}^{\text{scalebox}0.4LMPC,j}($$

$$\underset{{\mathbf{U}}_t^j,{\mathbf{\lambda }}_t^j}{\min }$$

$$x_{t|t}^j=x_t^j,$$

$${\mathbf{\lambda }}_t^j\ge 0,\text{mathds}1{\mathbf{\lambda }}_t^j=1,D_l^{j-1}(z_t^j){\mathbf{\lambda }}_t^j=x_{t+N|t}^j$$

$$x_{k+1|t}^j=A_{k|t}^j{x}_{k|t}^j+B_{k|t}^j{u}_{k|t}^j+C_{k|t}^j,$$

$$x_{k|t}^j\in \mathcal{X},u_{k|t}^j\in \mathcal{U},$$

$$\forall k=t,\cdots ,t+N-1,$$

$$h(x)=\{\begin{array}{ll}1& \text{mbox}Ifx\notin {\mathcal{X}}_F\\ 0& \text{mbox}Else\end{array}.$$

$${\mathbf{\lambda }}_t^{j,\ast },[x_{t|t}^{j,\ast },\dots ,x_{t+N|t}^{j,\ast }]\text{ and }{\mathbf{U}}_t^{j,\ast }$$

$$z_t^j=\{\begin{array}{ll}{x}_N^{j-1}& \text{mbox}Ift=0\\ S_l^j(z_{t-1}^j){\mathbf{\lambda }}_{t-1}^{j,\ast }& \text{mbox}Otherwise\end{array},$$

$$u_t^j=u_{t|t}^{j,\ast }.$$

$${\dot{e}}_{\psi }$$

$$\dot{s}$$

$${\dot{e}}_y$$

$$e_{{\psi }_{k+1}}$$

$$\displaystyle\quad+dt\Bigg{(}w_{z_{k}}-\frac{v_{x_{k}}\cos(e_{\psi_{k}})-v_{y_{k}}\sin(e_{\psi_{k}})}{1-\kappa(s_{k})e_{y_{k}}}\kappa(s_{k})\Bigg{)}$$

$$s_{k+1}$$

$${\dot{e}}_y$$

$$K(u)=\{\begin{array}{ll}\frac{3}{4}(1-u^2),& \text{mbox}for|u|<1\\ 0,& \text{mbox}else\end{array},$$

Full text

I Introduction

Autonomous driving is an active research field. Over the past decades several techniques have been proposed for different driving scenarios [1, 2, 3, 4, 5, 6, 7, 8, 9]. Depending on the control task (i.e. highway driving, urban driving, emergency maneuvers) the behavior of the vehicle can be modelled with linear or nonlinear equations of motions [10], [11]. When the nonlinearities of the vehicle are excited the control task is inevitably more challenging. In this work we are interested in designing a controller for autonomous racing which can operate the vehicle in the nonlinear regime, close to the limit of the vehicle’s handling capability. We formulate the autonomous racing problem as an iterative control task, where at each iteration the controller drives the vehicle around the track trying to minimize the lap time.

Recently several approaches have been proposed for autonomous racing. In [12] the authors reformulated the autonomous racing control task as a non-convex optimization problem and then proposed a linearization strategy to compute an approximate solution. The authors in [13] proposed a Nonlinear Model Predictive Control (NMPC) strategy which exploits a Pacejka tire model identified form experimental data. The NMPC is implemented on an experimental set-up using an exact Hessian SQP-type optimization algorithm. NMPC strategies for autonomous racing are tested also in [14], where the authors compared two control methodologies based on different parametrizations of the vehicle’s model. In [15] the authors compared two approaches, the first one based on a tracking MPC and the second one based on a MPC formulated in a space dependent frame. A Model Predictive Contouring Control (MPCC) was presented in [16]. In MPCC the controller objective is a trade-off between the progress along the track and the contouring error. First, an high level MPC computes the optimal racing trajectory. Afterward, a low level controller is used to track the optimal racing line. This strategy is extended in [17] to design a racing controller which guarantees recursive constraint satisfaction. Also in [18] the control problem is divided in two steps. First, a reference trajectory is computed using the method proposed in [19]. Afterwards, an iterative learning control (ILC) approach is used for tracking. The authors showed the effectiveness of the proposed approach by experimental testing on a full size vehicle. We proposed to reformulate the autonomous racing problem as an iterative control task. The controller is not based on a precomputed racing line and it learns from experience a trajectory which minimizes the lap time. In particular, the closed-loop trajectories at each lap are stored and used to systematically update the controller for the next lap. This paper builds on [20, 21, 22] and has two main contributions.

The first contribution is to propose a local LMPC strategy where the terminal cost and constraint are updated at each time step. In particular at each time $t$, we exploit the planned trajectory at time $t-1$ to construct a local terminal cost and constraint. Conversely to our previous works [20, 21, 22], the terminal cost and constraint are computed using a subset of the stored data, therefore the proposed local LMPC enables the reduction of computational burden associated with existing LMPC strategies. The effectiveness of the proposed approach is demonstrated on the Berkeley Autonomous Race Car (BARC)111A video of the experiment can be found at https://youtu.be/ZBFJWtIbtMo platform. We show that the proposed controller is able to improve the lap time, until it converges to a steady state behavior. Finally, we analyze the lateral acceleration acting on the closed-loop system and we confirm that the controller learns to drive the vehicle at the limit of its handling capability.

The second contribution of this work is to propose a system identification strategy tailored to the autonomous racing application. We propose to exploit both the kinematic equations of motion and data from previous iterations to identify an Affine Time Varying (ATV) prediction model used for control. In particular, we use a local linear regressor to learn the relationships between the inputs and the vehicle’s velocities. Furthermore, we linearize the kinematic equations of motion to approximate the evolution of the vehicle’s position as a function of the velocities. Conversely to our previous works [20, 21], this strategy allow us to reformulate the LMPC as a Quadratic Program (QP) which can be solved efficiently.

This paper is organized as follows: in Section II we introduce the problem formulation. Section III illustrates the LMPC design. In particular, it shows how to construct local safe sets and value function approximations using a subset of the collected data. Section IV illustrates the system identification strategy used in the experiments. Finally, in Section V we present the experimental results on the Berkeley Autonomous Race Car (BARC) platform. Section VIII provides final remarks.

II Problem Formulation

Consider the following state and input vectors

[TABLE]

where $w_{z},v_{x},v_{y},$ are the vehicle’s yaw rate, longitudinal and lateral velocities. The position of the vehicle is represented in the curvilinear reference frame [23], where $s$ is the distance travelled along the centerline of the track. The states $e_{\psi}$ and $e_{y}$ are the heading angle and lateral distance error between the vehicle and the centerline of the track, as shown in Figure 1. Finally, $\delta$ and $a$ are the steering and acceleration commands. The vehicle is described by the dynamic bicycle model

[TABLE]

where $f(\cdot,\cdot)$ is derived from kinematics and balancing the forces acting on the tires [10]. A detailed expression can be found in [10, Chapter 2]. Note that in the curvilinear reference frame state and input constraints are convex, i.e.

[TABLE]

The goal of the controller is to drive the system from the starting point $x_{S}$ to the terminal set $\mathcal{X}_{F}$. More formally, the controller aims to solve the following minimum time optimal control problem

[TABLE]

where for a track of length $L$ the terminal set

[TABLE]

represents the states beyond the finish line.

III Controller Design

In this section, we first show how to use historical data to construct a terminal constraint set and terminal cost function. Afterwards, we exploit these quantities to design the controller.

III-A Stored Data

As stated in the introduction, we define one iteration as a successful lap around the race track and we store the closed-loop trajectories. In particular, at the $j$th iteration we define the vectors

[TABLE]

which collect the evolution of closed-loop system and associated input sequence. In the above definitions, $T^{j}$ denotes the time at which the closed-loop system reached the terminal set, i.e. $x_{T^{j}}\in\mathcal{X}_{F}$.

III-B Local Convex Safe Set

In this section, we define the local convex safe set. Differently from our previous works [22, 20, 21], this quantity is constructed using a subset of the stored data points. In particular, the local convex safe set around $x$ is defined as the convex hull of the $K$-nearest neighbors to $x$.

First, for the $j$th trajectory we define the set of time indices $[t^{j,*}_{1},\ldots,t^{j,*}_{K}]$ associated with the $K$-nearest neighbors to the point $x$,

[TABLE]

In the above definition $||y||_{D}^{2}=y^{\top}D^{\top}Dy$ for the user-defined matrix $D$, which may be chosen to take into account the relative scaling or relevance of different variables. We chose $D=diag(0,0,0,0,1,0)$ to select the $K$-nearest neighbors with respect to the curvilinear abscissa $s$, which represents a proxy for the distance between two stored data points of the same lap. Furthermore, as the vehicle moves forward on the track, at each lap the stored data are ordered with respect to the travelled distance $s$ and the computation of (5) is simplified. The $K$-nearest neighbors to $x$ from the $l$th to the $j$th iteration are collected in the following matrix

[TABLE]

which is used to define the local convex safe set around $x$

[TABLE]

Notice that the above local convex safe set $\mathcal{CL}^{j}_{l}(x)$ represents the convex hull of the $K$-nearest neighbors to $x$ from the $l$th to $j$th iteration.

Finally, we define the matrix

[TABLE]

which collects the evolution of the states stored in the columns of the matrix $D_{l}^{j}(x)$. The above matrix $S_{l}^{j}(x)$ will be used in Section III-D to construct the local convex safe set at each time step.

III-C Local Convex Q-function

In this section, we exploit the stored data to construct an approximation to the cost-to-go over the local convex safe set $\mathcal{CL}^{j}_{l}(x)$ around $x$. In particular, we define the local convex $Q$-function around $x$ as the convex combination of the cost associated with the stored trajectories,

[TABLE]

where $\bm{\lambda}\in\mathbb{R}^{k(j-l)}$, $\mathds{1}$ is a row vector of ones and the row vector

[TABLE]

collects the cost-to-go associated with the $K$-nearest neighbors to $x$ from the $l$th the $j$th iteration. The cost-to-go $J_{t\rightarrow T^{j}}^{j}(x_{t}^{j})=T^{j}-t$ represents the time to drive the vehicle from $x_{t}^{j}$ to the finish line along the $j$th trajectory. We underline that the cost-to-go is computed after completion of the $j$th iteration.

III-D Local LMPC Design

The local convex safe set and the local convex $Q$-function are used to design the controller. At each time $t$ of the $j$th iteration the controller solves the following finite time optimal control problem

[TABLE]

where ${\bf{U}}_{t}^{j}=[u_{t|t}^{j},\ldots,u_{t+N-1|t}^{j}]\in\mathbb{R}^{d\times N}$, $\bm{\lambda}_{t}^{j}\in\mathbb{R}^{(j-l+1)K}$ and the stage cost in (8a)

[TABLE]

In the above finite time optimal control problem equations (8b), (8d) and (8e) represent the dynamic update, state and input constraints. Finally, (8c) enforces $x_{t+N|t}^{j}$ into the local convex safe set defined in Section III-B. The optimal solution to (8) at time $t$ of the $j$th iteration

[TABLE]

is used to compute the following vector

[TABLE]

which at time $t$ defines the local convex safe set $\mathcal{LS}^{j}_{l}(z_{t}^{j})$ and local $Q$-function $Q^{j}_{l}(x,z_{t}^{j})$ in (8). The above vector $z_{t}^{j}$ represents a candidate terminal state for the planned trajectory of the LMPC at time $t$. First, we initialize the candidate terminal state $z_{0}^{j}$ using the $(j-1)$th trajectory. Afterwards, we update the vector $z_{t}^{j}$ as the convex combination of the columns of the matrix $S_{l}^{j}(z_{t}^{j})$ from Section III-B. Notice that if the systems is linear or if a linearized system approximates the nonlinear dynamics over the local convex safe set, then there exists a feasible input which drives the system from $x_{t+N|t}^{j,*}=D_{t}^{j-1}(z_{t}^{j})\bm{\lambda}_{t}^{j,*}$ to $z_{t+1}^{j}=S_{l}^{j-1}(z_{t}^{j})\bm{\lambda}_{t}^{j,*}$.

Finally, we apply to the system (1) the first element of the optimizer vector,

[TABLE]

The finite time optimal control problem (8) is repeated at time $t+1$, based on the new state $x_{t+1|t+1}=x_{t+1}^{j}$.

IV System Identification Strategy

In this section, we illustrate the system identification strategy used to build an Affine Time Varying (ATV) model which approximates the vehicle dynamics. First, we introduce the kinematic equations of motion which describe the evolution of the vehicle’s position as a function of the velocities. Afterwards, we present the strategy used to approximate the dynamic equations of motion, which model the evolution of the vehicle’s velocities as a function of the input commands. Finally, we describe the ATV model, which is computed online linearizing the kinematic equations of motion and evaluating the approximate dynamic equations of motion along the shifted optimal solution to the LMPC.

IV-A Kinematic Model

As mentioned in Section II, the position of the vehicle is expressed in the Frenet reference frame [23]. In particular, we describe the position of the vehicle in terms of lateral distance $e_{y}$ from the centerline of the road and distance $s$ traveled along a predefined path (Fig. 1). The state $e_{\psi}$ represents the difference between the vehicle’s heading angle and the angle of the tangent vector to the path at the curvilinear abscissa $s$.

The rate of change of the vehicle’s position in the curvilinar reference frame is described by the following kinematic relationships

[TABLE]

where $\kappa(s)$ is the curvature of the centerline of the track at the curvilinear abscissa $s$ [23]. The above equations can be Euler discretized to approximate the vehicle’s motion as a function of the vehicle’s velocities

[TABLE]

where $dt$ is the discretization time. The above equations will be linearized to compute an ATV prediction model. It is interesting to notice that equations (12) are independent of the vehicle’s physical parameters, because these are derived from kinematic relationships between velocities and position.

IV-B Dynamic Model

The dynamic equations of motion, which describe the evolution of the vehicle’s velocities, may be computed balancing the forces acting on the tires [10]. Therefore, the dynamic equations depend on physical parameters associated with the vehicle, tires and asphalt. These parameters may be estimated through a system identification campaign. However, the nonlinear dynamic equations of motion should be linearized in order to obtain an ATV model which allows us to reformulate the LMPC as a QP. Instead of identifying the parameters of a nonlinear model and then linearize it, we propose to directly learn a linear model around $x$ using a local linear regressor. We introduce the Epanechnikov kernel function [24]

[TABLE]

which is used to compute a local linear model around $x$ for the longitudinal and lateral dynamics. In particular, for $l=\{v_{x},v_{y},w_{z}\}$ we compute the following regressor vector

[TABLE]

where the hyperparameter $h\in\mathbb{R}_{+}$ is the bandwidth, the row vector $\Gamma\in\mathbb{R}^{5}$,

[TABLE]

and $I^{j}_{l}(x)$ is the set of indices

[TABLE]

where $||y||_{Q}=y^{\top}Q^{\top}Qy$ and the matrix $Q$ is user defined. For the stored data from iteration $l$ to iteration $j$, the set $I^{j}_{l}(x)$ collects the indices associated with the $P$-nearest neighbors to the state $x$. Finally, the user-defined matrix $Q$ takes into account the relative scaling of different variables.

Notice that the optimizer in (13) can be used to approximate the evolution of vehicle’s velocities,

[TABLE]

where for $l=\{v_{x},v_{y},w_{z}\}$ the scalar $\Gamma_{i}^{l}(x)$ denotes the $i$th element of the vector $\Gamma^{l}(x)$ and $\Gamma_{1:3}^{l}(x)\in\mathbb{R}^{3}$ is a row vector collecting the first three elements of $\Gamma^{l}(x)$ in (13).

IV-C Affine Time Varying Model

In this section we describe the strategy used to build an ATV model, which is then used for control. At time $t$ of the $j$th iteration we define the candidate solution $\bar{\bf{x}}_{t}^{j}=[\bar{x}_{t|t}^{j},\ldots,\bar{x}_{t+N|t}^{j}]$ to Problem (8) using the optimal solution at time $t-1$ from (9),

[TABLE]

Finally at each time $t$ of iteration $j$, the above candidate solution is used to build the following ATV model

[TABLE]

where $x_{k|t}^{j}=[v_{x_{k|t}}^{j},v_{y_{k|t}}^{j},w_{y_{k|t}}^{j},e_{\psi_{k|t}}^{j},s_{{k|t}}^{j},e_{y_{k|t}}^{j}]$ and the matrices $A_{k|t}^{j}$, $B_{k|t}^{j}$ and $C_{k|t}^{j}$ are obtained linearizing (12) around $\bar{x}_{k|t}^{j}$ and evaluating (14) at $\bar{x}_{k|t}^{j}$,

[TABLE]

and

[TABLE]

V Results

The proposed control strategy has been implemented on a 1/10-scale open source vehicle platform called Berkeley Autonomous Race Car222A video of the experiment can be found at https://youtu.be/ZBFJWtIbtMo (BARC). The vehicle is equipped with a set of sensors, actuators and two on-board CPUs to perform low-level control of the actuators as well as communication with a laptop, on which the high-level control is implemented. The CPUs are an Arduino Nano for low-level control of the actuators and an Odroid XU4 for WiFi communication with the i7 MSI GT72 laptop. The actuators are an electrical motor and a servo for the steering. The control architecture has been implemented in the Robot Operating System (ROS) framework, using Python and OSQP [25]. The code is available online333The code is available on the BARC GitHub repository in the “devel-ugo” branch (github.com/MPC-Berkeley/barc).

We initialize the algorithm performing two laps of path following at constant speed. Each $j$th iteration collects the data of two consecutive laps. Therefore, the local safe set and local $Q$-function are defined also beyond the finish line. This strategy allows us to implement the LMPC for the repetitive autonomous racing control task, as shown in [20]. At each $j$th lap, we use the LMPC (8) and (11) to drive the vehicle from the starting line to the finish line and we use the closed-loop data to update the controller for the next lap. The parameters which define the controller are reported in Table I. We also added a small input rate cost in order to guarantee a unique solution to the QP associated with the LMPC.

We tested the controller on an oval-shaped and L-shaped tracks on which the vehicle runs in the counter-clockwise direction. Figure 2 shows that the lap time decreases until convergence is reached after $29$ laps. Furthermore, Figure 4 shows the evolution of the closed-loop trajectory on the X-Y plane and the velocity profile which is color coded. In the first row we reported the path following trajectory used to initialize the LMPC and the closed-loop trajectories at laps $7$ and $15$. We notice that the controller deviates from the initial feasible trajectory (reported in blue as the vehicle speed is $1.2$m/s) in order to explore the state space and to drive the vehicle at higher speeds, until it converges to a steady-state behavior. The steady-state trajectories from lap $30$ to $34$ are reported in the bottom row of Figure 4. Notice that the color bar representing the velocity profile changed from the first to second row as the vehicle runs at higher speed at the end of the learning process. We underline that the controller understands the benefit of breaking right before entering the curve and of accelerating when exiting. This behavior is optimal in racing as shown in [26].

Figure 3 shows the raw acceleration measurements from the IMU. We confirm that controller is able to operate the vehicle at the limit of its handling capability, reaching a maximum lateral acceleration close to $1$g 444The maximum allowed lateral acceleration is computed assuming that the aerodynamic effects are negligible and the that lateral force acting on the vehicle is $F=\mu mg$ for the friction coefficient $\mu=1$..

Furthermore, Figure 5 shows the data points used to design the LMPC. Recall from Table I that at the $j$th lap the LMPC policy is synthesized using the trajectories from lap $l=j-2$ to lap $j-1$. Therefore, as the controller drives faster on the track, less data points are needed to design the LMPC. Moreover, in Figure 6 we reported the computational time. It is interesting to notice that on average the finite time optimal control problem (8) is solved in less then $10$ms, whereas it took $90$ms to solve the finite time optimal control problem associated with [20]. We underline that both strategies have been tested with a prediction horizon of $N=12$ and a sampling time of $10$Hz. This shows the advantage of using the local convex safe set in (6), instead of the polynomial approximation to the safe set used in [21, 20]. For more details on the polynomial approximation to the safe set we refer to [21]. Finally, we notice that it would be possible to parallelize the computation of the $N-1$ linear models which define the ATV model from (15). Indeed, at time $t$ Equations (16)-(17) may be evaluated independently and in parallel for each predicted time $k$.

VI Conclusions

We presented a Learning Model Predictive Controller (LMPC) for autonomous racing. The proposed control framework uses historical data to construct safe sets and approximations to the value function. These quantities are systematically updated when a lap is completed, as a result the LMPC learns from experience to safely drive the vehicle at the limit of handling. We demonstrated the effectiveness of the proposed strategy on the Berkeley Autonomous Race Car (BARC) platform. Experimental results show that the controller learns to drive the vehicle aggressively, in order to minimize the lap time. In particular, the closed-loop system converged to a steady-state trajectory which cuts curves and reaches a lateral acceleration close to $1$g.