stein-variational-uncertainty-mpc - SKILL.md Agent Skill

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

Particle Representation
- Set of parameter samples: {θ₁, θ₂, ..., θ_N}
- Each particle represents a possible system parameter
- Distribution approximation through particle ensemble
Task-Dependent Uncertainty
- Focus on parameters most relevant to current task
- Adaptive particle distribution based on task context
- Concentrate on task-sensitive parameter regions
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

Stein variational methods provide deterministic particle-based uncertainty representation
Task-dependent focus reduces conservatism by concentrating on relevant parameters
Repulsive forces maintain particle diversity for distribution coverage
Particle-based MPC enables distributionally robust control without worst-case optimization
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