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)

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

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

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

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

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

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

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

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