Source-linked AI summary
Learning How to Autonomously Race a Car: a Predictive Control Approach
Ugo Rosolia, Francesco Borrelli
TL;DR
The paper addresses autonomous racing as a minimum-time iterative control problem in which the controller must learn fast, safe behavior from completed laps. It proposes a learning model predictive controller using historical trajectories, local safe sets, value-function approximations, and an affine time-varying prediction model. Experiments on the BARC platform show convergence to aggressive steady-state racing with lateral acceleration close to 1g.
Problem
Autonomous racing requires a controller that minimizes lap time while operating the vehicle near the limit of its handling capability.
Method
The LMPC stores trajectories from previous laps and uses subsets of those data with vehicle kinematics to update safe sets, value-function approximations, and an affine time-varying prediction model.
Results
Experiments on the BARC platform show convergence to a steady-state trajectory that cuts curves and reaches lateral acceleration close to 1g.
Takeaways & Limitations
The proposed LMPC learns from experience to drive aggressively while minimizing lap time and safely operating at the vehicle’s handling limit.
Abstract
from arXiv · showhide
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.
I. INTRODUCTION
The paper formulates autonomous racing as an iterative minimum-time control problem near the vehicle’s handling limit and proposes a learning controller that updates from completed laps. Its contributions are a local LMPC design that reduces computation and a data-driven affine time-varying prediction model.
- Autonomous racing is formulated as an iterative control task in which each lap minimizes time while operating near the vehicle’s handling limit.
- The controller stores closed-loop trajectories from each lap and uses them to systematically update the next lap without relying on a precomputed racing line.
- The local LMPC updates terminal costs and constraints at each time step using a subset of stored data, reducing the computational burden of existing LMPC strategies.
- A system-identification strategy combines vehicle kinematics with data from previous iterations to construct an affine time-varying prediction model for control.
- The vehicle is modeled with dynamic equations in a curvilinear reference frame, where position is represented by traveled distance and lateral and heading errors relative to the track.
III. CONTROLLER DESIGN
The controller design uses stored closed-loop lap data to construct terminal ingredients for learning model predictive control. Each completed lap contributes a trajectory and input sequence that can support subsequent controller updates.
- Historical data are used to construct a terminal constraint set and terminal cost function for the controller.
- A. Stored Data: Each successful lap is treated as one iteration, and its closed-loop state trajectory and associated input sequence are stored.
B. Local Convex Safe Set
The local convex safe set uses a subset of stored trajectory data to represent states that can support the controller. It is constructed around a state from its K-nearest stored neighbors, selected using a distance metric based on the curvilinear abscissa.
- B. Local Convex Safe Set: The local convex safe set around x is the convex hull of the K-nearest neighbors to x from stored trajectories.
- B. Local Convex Safe Set: The K-nearest neighbors are selected using a user-defined scaling matrix, chosen here to prioritize curvilinear abscissa s as a proxy for same-lap distance.
- B. Local Convex Safe Set: The method collects neighboring states across stored iterations and uses them to construct the local safe set around the current state.
C. Local Convex Q-function
The local convex Q-function approximates cost-to-go near a state by combining costs from nearby stored trajectory points. Each stored cost-to-go equals the remaining time to the finish line along its trajectory.
- C. Local Convex Q-function: The local convex Q-function is a convex combination of the costs associated with stored trajectories near x.
- C. Local Convex Q-function: The neighboring costs are drawn from the K-nearest neighbors to x across iterations l through j.
- C. Local Convex Q-function: Each cost-to-go is the time remaining to drive from the stored state to the finish line along its trajectory.
D. Local LMPC Design
The local LMPC repeatedly solves a finite-time optimal control problem using the local safe set and Q-function. It initializes and updates a candidate terminal state from stored trajectory data before applying the first optimized input.
- D. Local LMPC Design: At each time step, the controller solves a finite-time optimal control problem using the local convex safe set and local Q-function.
- D. Local LMPC Design: The optimization enforces dynamics, state and input constraints, and terminal inclusion in the local convex safe set.
- D. Local LMPC Design: The candidate terminal state is initialized from the previous trajectory and then updated as a convex combination of stored states.
- D. Local LMPC Design: Feasibility requires that a suitable input can drive the system from the predicted state into the local safe set under linear or locally linearized dynamics.
- D. Local LMPC Design: The optimization is repeated at the next time step using the newly measured state, and the first optimizer input is applied to the system.
IV. SYSTEM IDENTIFICATION STRATEGY
The system identification strategy builds an Affine Time Varying model of vehicle dynamics by combining kinematic equations with data-driven approximation of velocity dynamics.
- IV. SYSTEM IDENTIFICATION STRATEGY: The strategy builds an Affine Time Varying model that approximates vehicle dynamics for control.
- IV. SYSTEM IDENTIFICATION STRATEGY: Kinematic equations describe position evolution from velocities, while the dynamic equations model velocity evolution from input commands.
A. Kinematic Model
The kinematic model describes vehicle position in the Frenet frame and discretizes its motion from velocity relationships, independently of physical vehicle parameters.
- A. Kinematic Model: The model represents position using lateral error e_y, heading error e_ψ, and distance s along the track centerline.The heading error is measured relative to the path tangent at the vehicle’s curvilinear position.
- A. Kinematic Model: Kinematic relationships describe how the vehicle’s position changes in the curvilinear reference frame.The track curvature κ(s) enters these relationships at the corresponding curvilinear abscissa.
- A. Kinematic Model: Euler discretization approximates the vehicle’s motion as a function of its velocities.The discretization supports construction of the prediction model used for control.
- A. Kinematic Model: The kinematic equations are independent of vehicle physical parameters because they arise from relationships between velocities and position.They are later linearized to compute an affine time-varying prediction model.
B. Dynamic Model
The dynamic model learns local velocity relationships from nearby stored data and combines them with a linearized vehicle model to obtain an affine time-varying representation.
- B. Dynamic Model: The dynamic equations describe vehicle velocity evolution through forces acting on the tires and depend on vehicle, tire, and asphalt parameters.These physical parameters may be estimated through system identification.
- B. Dynamic Model: A local linear model is constructed around the current state for longitudinal and lateral vehicle dynamics.The regressor is formed for the velocities v_x, v_y, and yaw rate w_z.
- B. Dynamic Model: The local model uses a bandwidth hyperparameter and a row-vector representation to parameterize the regression.The bandwidth h is positive, while Γ is a five-dimensional row vector.
- B. Dynamic Model: Nearest neighbors are selected from stored data using a user-defined weighted norm and relative variable scaling.The neighbor index set is formed over iterations l through j, with distinct stored samples selected by the indexing constraints.
- B. Dynamic Model: The resulting optimizer approximates the evolution of the vehicle’s velocities and supports an affine time-varying model for control.The model is obtained after the nonlinear dynamics are linearized so the LMPC can be reformulated as a quadratic program.
C. Affine Time Varying Model
At each iteration and time step, the controller builds a candidate solution from the previous optimization result and uses it to construct the affine time-varying prediction model.
- C. Affine Time Varying Model: The ATV-model construction begins by defining a candidate solution at time t of iteration j.This candidate is part of the strategy used to build the model for control.
- C. Affine Time Varying Model: The candidate solution is obtained by applying the previous time step’s optimal solution to the control problem.The construction uses the optimal solution at time t−1 from the preceding optimization.
- C. Affine Time Varying Model: The candidate solution is used at every time t of iteration j to build the ATV model.This makes the prediction model time-varying along the iteration.
- C. Affine Time Varying Model: The model coefficients are obtained by linearizing the kinematic equations and evaluating the local dynamics around the candidate state.Both operations are performed around the candidate trajectory state at the relevant prediction step.
V. RESULTS
Experiments on oval-shaped and L-shaped tracks show that the LMPC learns faster, limit-handling behavior while reducing online optimization cost through local data selection.
- Handling performance: Maximum lateral acceleration reaches close to 1g, confirming operation near the vehicle’s handling limit.The result is based on raw IMU acceleration measurements.
- Computational cost: The finite-time optimal control problem averages less than 10 ms, versus 90 ms for the approach in.Both methods use prediction horizon N = 12 and sampling time 10 Hz.
- Data usage: As the controller drives faster, fewer stored data points are needed to design the LMPC.At lap j, the policy uses trajectories from laps j−2 through j−1.
VI. CONCLUSIONS
The paper presents an LMPC that learns from completed laps to drive a race car safely and aggressively near its handling limit. Experiments on BARC show convergence to a steady-state trajectory that cuts curves and reaches lateral acceleration close to 1g.
- Conclusions: Historical trajectories update safe sets and value-function approximations after each lap, enabling the LMPC to learn autonomous racing behavior.The strategy was demonstrated on the Berkeley Autonomous Race Car platform.
- Conclusions: The closed-loop system converges to a steady-state trajectory that cuts curves and reaches lateral acceleration close to 1g.The conclusion reports aggressive driving to minimize lap time.