Mpc Autonomous Driving Sim Eval

---
name: mpc-autonomous-driving-sim-eval
description: Evaluates an alternating minimization model predictive control (MPC) framework for autonomous driving against a joint optimization baseline, focusing on computational efficiency, trajectory smoothness, and safety margins during critical maneuvers like overtaking, lane changes, and sudden braking. Use when the user wants to benchmark on CARSIM Simulation Benchmarks, or asks about evaluating this task. Reports iterations.
metadata:
  skill_kind: dataset_eval
  source_arxiv: 1803.03478
  bibtex_key: [REDACTED]
  confidence: high
---

# mpc-autonomous-driving-sim-eval

> Model Predictive Control for Autonomous Driving considering Actuator Dynamics — Babu et al. (2018) (arXiv:1803.03478, 2018)

## What this evaluates

Evaluates an alternating minimization model predictive control (MPC) framework for autonomous driving against a joint optimization baseline, focusing on computational efficiency, trajectory smoothness, and safety margins during critical maneuvers like overtaking, lane changes, and sudden braking.

## Datasets

- **CARSIM Simulation Benchmarks** — total ?; splits: (unstated)

## Metrics

- `iterations` **(primary)** — range: count
  - Number of alternating minimization iterations required to converge to a solution.
- `runtime` — range: seconds
  - Wall-clock time in seconds to compute one MPC optimization step.
- `smoothness_cost` — range: other
  - Aggregate penalty on the rate of change of velocity and angular acceleration over the planning horizon.
- `inter_vehicle_distance` — range: meters
  - Minimum distance in meters between the ego vehicle and an obstacle vehicle during a maneuver.

## Input / output format

**Input**: Ego-vehicle kinematic state, obstacle states from virtual LIDAR (70m range), road boundary constraints, and velocity/acceleration bounds.

**Output**: Sequence of linear velocity and angular acceleration commands over a 50-step horizon (0.1s per step).

## Scoring recipe

```python
def compute_metrics(predictions, gold):
    runtime = predictions['runtime_sec']
    iterations = predictions['num_iterations']
    smoothness = sum((v[i+1]-v[i])**2 for v in predictions['velocity']) + \
                 sum((a[i+1]-a[i])**2 for a in predictions['angular_accel'])
    min_dist = min(predictions['distances'])
    return {'runtime': runtime, 'iterations': iterations, 'smoothness_cost': smoothness, 'inter_vehicle_distance': min_dist}
```

## Common pitfalls

- Comparing AM and joint optimization solely on optimality without considering the significant runtime and iteration savings of AM.
- Evaluating braking/acceleration performance using idealized kinematic models instead of explicit actuator dynamics, which masks transient overshoot and damping differences.

## Evidence (verbatim from paper)

> As shown, on an average, our proposed AM approach takes around 17% less time and 32% less iterations. As shown in Fig.[4], both our AM and joint formulation results in low smoothness cost. However, smoothness cost obtained with joint formulation is significantly lower than that obtained with our AM.

## Citation

```bibtex
@misc{babu2018mpcactuator,
  title={Model Predictive Control for Autonomous Driving considering Actuator Dynamics},
  author={Babu et al. (2018)},
  year={2018},
  note={arXiv:1803.03478}
}
```

- arXiv: 1803.03478