Stein Variational Uncertainty Mpc

---
name: stein-variational-uncertainty-mpc
description: "Stein variational distributionally robust controller for nonlinear systems with latent parametric uncertainty. Uses particle-based approximation of task-dependent uncertainty distribution. Use when: (1) Designing MPC with parameter uncertainty, (2) Implementing uncertainty-adaptive model predictive control, (3) Building distributionally robust controllers for nonlinear systems, (4) Handling latent parametric uncertainty, (5) Developing particle-based uncertainty quantification methods."
---

# Stein Variational Uncertainty-Adaptive Model Predictive Control

## Overview

This work proposes a Stein variational distributionally robust controller for nonlinear dynamical systems with latent parametric uncertainty. The key innovation is using a deterministic particle-based approximation to capture task-dependent uncertainty distributions.

**Paper**: arXiv:2604.01034 (April 2026)
**Category**: eess.SY, cs.SY, math.OC

## Core Innovation: Stein Variational Approach

### Problem: Latent Parametric Uncertainty
- **Challenge**: Unknown system parameters affecting dynamics
- **Traditional approach**: Worst-case ambiguity-set optimization (conservative)
- **Limitation**: Ignores task-dependent parameter sensitivity

### Stein Variational Solution
Instead of worst-case optimization, use:
- **Particle-based uncertainty representation**
- **Task-dependent distribution focus**
- **Stein variational gradient descent for distribution approximation**

## Mathematical Framework

### Stein Variational Gradient Descent (SVGD)
```python
class SteinVariationalController:
    def __init__(self, nominal_parameters, uncertainty_prior):
        self.particles = self.initialize_particles(nominal_parameters, uncertainty_prior)
        self.task_context = None

    def update_particles(self, observations, task_objective):
        # SVGD update: deterministic particle evolution
        for particle in self.particles:
            gradient = self.compute_task_sensitive_gradient(particle, task_objective)
            repulsive_force = self.compute_repulsive_force(particle, self.particles)
            particle.update(gradient - repulsive_force)

    def compute_task_sensitive_gradient(self, particle, task):
        # Gradient toward task-relevant parameter regions
        task_gradient = self.task_performance_gradient(particle, task)
        likelihood_gradient = self.data_likelihood_gradient(particle)
        return task_gradient + likelihood_gradient
```

### Key Components

1. **Particle Representation**
   - Set of parameter samples: {θ₁, θ₂, ..., θ_N}
   - Each particle represents a possible system parameter
   - Distribution approximation through particle ensemble

2. **Task-Dependent Uncertainty**
   - Focus on parameters most relevant to current task
   - Adaptive particle distribution based on task context
   - Concentrate on task-sensitive parameter regions

3. **Stein Variational Updates**
   - Gradient toward high-performance regions
   - Repulsive force to maintain diversity
   - Deterministic particle evolution (no random sampling)

## SVGD Mechanism

### Gradient Computation
```python
def stein_gradient(particle_set, target_distribution):
    gradients = []
    for i, particle in enumerate(particle_set):
        # Attractive force toward target
        attractive = compute_gradient(particle, target_distribution)

        # Repulsive force from other particles
        repulsive = 0
        for j, other_particle in enumerate(particle_set):
            if i != j:
                repulsive += kernel_function(particle, other_particle) *
                            gradient_kernel(other_particle)

        gradients.append(attractive + repulsive)

    return gradients
```

### Kernel Function
```python
def kernel_function(theta_i, theta_j):
    # RBF kernel for particle diversity
    return exp(-||theta_i - theta_j||^2 / (2 * h^2))
```

Where **h** is bandwidth parameter controlling particle spread.

## Distributionally Robust MPC Formulation

### Control Problem
```
minimize: max_{P ∈ ParticleDistribution} E_P[cost(x, u, θ)]
subject to: dynamics: x_{t+1} = f(x_t, u_t, θ)
            particles: θ_i ∈ ParticleSet
            constraints: g(x, u, θ) ≤ 0 for all θ ∈ ParticleSet
```

### Particle-Based MPC
```python
class ParticleBasedMPC:
    def solve_control_problem(self, current_state, particles):
        # Min-max over particle distribution
        worst_particle = self.find_worst_case_particle(particles, current_state)
        optimal_action = self.solve_ocp(current_state, worst_particle)

        # Verify robustness across all particles
        self.verify_constraints(current_state, optimal_action, particles)

        return optimal_action

    def find_worst_case_particle(self, particles, state):
        # Select particle leading to worst performance
        performances = [self.evaluate_task_performance(p, state) for p in particles]
        worst_idx = argmin(performances)
        return particles[worst_idx]
```

## Task-Dependent Uncertainty Focus

### Key Insight: Not All Parameters Matter Equally
For a specific task, only some parameters are critical:
- **Navigation task**: Environment friction matters
- **Energy task**: Efficiency parameters matter
- **Safety task**: Constraint parameters matter

### Task-Sensitive Distribution Update
```python
def task_sensitive_particle_update(particles, task_objective, observations):
    # Focus particles on task-relevant regions
    for particle in particles:
        # Compute gradient toward task-optimal parameters
        task_gradient = task_performance_gradient(particle, task_objective)
        # Compute gradient from data likelihood
        data_gradient = likelihood_gradient(particle, observations)
        # Combine with repulsive force for diversity
        update = task_gradient + data_gradient + repulsive_force(particle, particles)
        particle.update(update)
```

## Advantages Over Traditional Methods

### 1. Less Conservative Than Worst-Case DROC
- Focuses on task-relevant uncertainty
- Avoids worst-case over-engineering
- Concentrates particles where they matter

### 2. Deterministic Updates
- No random sampling noise
- Reproducible particle evolution
- Stable convergence properties

### 3. Adaptive Uncertainty Focus
- Task-dependent particle distribution
- Real-time uncertainty adaptation
- Efficient uncertainty representation

### 4. Computational Efficiency
- Finite particle set (not infinite distribution)
- Gradient-based updates (fast convergence)
- Parallel particle evaluation possible

## Applications

### 1. Aerospace Systems
- Aircraft control under aerodynamic parameter uncertainty
- Spacecraft trajectory optimization
- Turbofan engine robust control

### 2. Autonomous Vehicles
- Path planning under vehicle parameter uncertainty
- Adaptive cruise control
- Lane keeping with uncertain dynamics

### 3. Robotics
- Manipulator control under load uncertainty
- Mobile robot navigation
- Human-robot interaction control

### 4. Process Control
- Chemical reactor control
- Power plant optimization
- Manufacturing process control

## Implementation Guide

### Particle Initialization
```python
def initialize_particles(nominal_params, prior_distribution, N=20):
    particles = []
    for i in range(N):
        # Sample from prior around nominal
        particle = nominal_params + sample_from_prior(prior_distribution)
        particles.append(particle)
    return particles
```

### SVGD Update Step
```python
def svgd_step(particles, observations, task, bandwidth=1.0):
    N = len(particles)
    for i in range(N):
        # Compute attractive gradient
        grad_log_p = log_posterior_gradient(particles[i], observations, task)

        # Compute repulsive term
        repulsive = 0
        for j in range(N):
            k_ij = rbf_kernel(particles[i], particles[j], bandwidth)
            grad_k_j = kernel_gradient(particles[j], particles[j], bandwidth)
            repulsive += k_ij * grad_k_j / N

        # Update particle
        particles[i] += epsilon * (grad_log_p + repulsive)
```

### MPC Integration
```python
def particle_based_mpc(particles, state, horizon=10):
    # Build particle-based dynamics model
    dynamics_models = [build_model(p) for p in particles]

    # Solve robust MPC
    worst_dynamics = find_worst_case(dynamics_models, state)
    optimal_trajectory = solve_ocp(state, worst_dynamics, horizon)

    return optimal_trajectory[0]  # First action
```

## Key Parameters

- **Particle count N**: 10-50 typical (balance coverage vs. computation)
- **Kernel bandwidth h**: Median particle distance heuristic
- **Update step ε**: Small enough for stability, large enough for adaptation
- **MPC horizon**: Standard MPC choices (5-20 steps)

## Research Contributions

- Stein variational approach for distributionally robust control
- Task-dependent uncertainty quantification
- Particle-based MPC framework
- Nonlinear system robust control
- Computational methods for real-time implementation

## Comparison with Methods

| Method | Uncertainty Type | Conservatism | Adaptability | Computation |
|--------|------------------|--------------|--------------|-------------|
| Nominal MPC | None | None | No | Low |
| Robust MPC | Worst-case | High | No | Medium |
| Stochastic MPC | Known distribution | Low | No | Medium-High |
| **Stein Variational MPC** | **Task-dependent** | **Medium** | **Yes** | **Medium** |

## Key Takeaways

1. **Stein variational methods** provide deterministic particle-based uncertainty representation
2. **Task-dependent focus** reduces conservatism by concentrating on relevant parameters
3. **Repulsive forces** maintain particle diversity for distribution coverage
4. **Particle-based MPC** enables distributionally robust control without worst-case optimization
5. **Nonlinear systems** benefit from flexible particle representation

## Reference

- **Full paper**: https://arxiv.org/abs/2604.01034
- **PDF**: https://arxiv.org/pdf/2604.01034
- **Category**: eess.SY, cs.SY, math.OC
- **Keywords**: Stein variational gradient descent, model predictive control, distributionally robust control, particle methods, uncertainty quantification