Safe Exploration and Optimization with Gaussian Processes

72 concepts65 papers5 proposals

When deploying machine learning to physical systems—such as tuning quadrotor controllers (Berkenkamp et al.), optimizing legged locomotion (Widmer et al.), or fast-charging lithium-ion batteries (Hirt et al.)—the traditional paradigm of trial-and-error exploration breaks down. In these real-world domains, a single violation of a safety constraint can result in catastrophic hardware failure or physical danger.

To learn optimal behaviors without risking failure, an agent must be able to predict whether an unvisited state or parameter configuration is safe before executing it. The core idea behind this research direction is to use Gaussian Processes (GPs) to model unknown safety constraints, leveraging their explicit quantification of uncertainty to provide rigorous, high-probability safety guarantees during exploration and optimization.


The Core Mechanism: Pessimism Under Epistemic Uncertainty

The fundamental reason Gaussian Processes are uniquely suited for safe learning is that they do not merely provide a point prediction; they model a distribution over functions. For any arbitrary input $x$ (which could represent a robot's state or a controller's parameters), a GP yields both a predicted mean $\mu(x)$ and a predictive variance $\sigma^2(x)$. This variance represents epistemic uncertainty—the system's lack of knowledge due to a scarcity of data in that region of the space.

To guarantee safety, algorithms in this domain adopt a principle of pessimism under uncertainty. Suppose a system is safe as long as an unknown constraint function $g(x)$ remains above a critical threshold (e.g., $g(x) \ge 0$). As formalized by Kim et al., we can construct a conservative lower bound of our safety function:

$$g_{\text{LCB}}(x) = \mu(x) - \beta \sigma(x)$$

where $\beta$ is a scaling factor chosen to dictate the statistical confidence level.

Constraint Value g(x)
  ^
  |       True Constraint Function (Unknown)
  |           /---\
  |          /     \       _..---.._
  |   _..---/-------\-----/---------\--  <- Safety Threshold (0)
  |  /     /         \   /           \
  | /     /  GP Mean  \_/             \
  |======[=============================]====> Input Space (x)
  |       \   \       / \             /
  |        \   \_____/   \___________/   <- Lower Confidence Bound (LCB)
  |         \___________/
  |
  |      [--- Safe Set ---]

An optimizer or reinforcement learning agent restricts its actions exclusively to a "safe set" where $g_{\text{LCB}}(x) \ge 0$. Because the true function lies above this lower bound with high probability, the agent can evaluate new points within this set with zero catastrophic failures during the exploration phase (Gassol Puigjaner et al.; Tokmak et al.).


The Mechanics of Safe Expansion

If an agent only evaluates points that are already guaranteed to be safe, it risks getting trapped in a local, overly cautious sub-optimal zone. How can it safely discover better configurations in completely unvisited parts of the space?

The solution relies on smoothness assumptions (typically encoded via the GP's kernel function or Lipschitz continuity parameters). Because the function cannot change discontinuously, evaluating a point inside the safe set simultaneously reduces the predictive variance $\sigma(x)$ for nearby points outside the current safe set.

This insight drives algorithms like SafeMDP (Berkenkamp et al.) and STAGEOPT (Sui et al.). The expansion process operates as a sequence of deliberate steps:

  1. Identify the Frontier: Locate points within the verified safe set that are close to the unknown boundary.
  2. Target High Uncertainty: Select a point where the model's uncertainty is high, but whose worst-case estimate is still safely above the threshold.
  3. Shrink the Error Bars: Evaluating this point collapses the variance around it.
  4. Expand the Boundary: As the variance shrinks, the LCB of adjacent, previously uncertain points rises above the safety threshold, automatically expanding the "safely operable region" (Marco et al.).

By actively sampling the most uncertain points within the verified safe region, the system reduces model variance at the boundaries, allowing for the incremental, secure expansion of its operational zone (Berkenkamp et al.; Berkenkamp et al.).


Decoupling Exploration from Optimization

A key algorithmic challenge in this domain is balancing the desire to expand the safe set with the desire to maximize performance. Early approaches interleaved these goals, which often led to sample inefficiency.

To resolve this, Sui et al. introduced a stagewise separation: the algorithm first focuses entirely on expanding the safe search space to its maximum possible extent, and only then switches to maximizing utility within that verified region.

In settings where optimization and exploration must happen concurrently—such as bandit optimization—algorithms like SGP-UCB (Thrampoulidis et al.) and Safe Frank-Wolfe (Krause et al.) maintain a conservative inner-approximation of the feasible region. They prove that by using GP confidence intervals to filter out risky actions, a learner can achieve sub-linear regret—meaning it finds the global optimum as fast as traditional unconstrained algorithms—while maintaining a zero-violation record throughout the entire learning process.


Scaling to Complex Dynamics

While the mathematical foundations assume well-behaved Gaussian noise and low-dimensional spaces, recent developments have extended this paradigm to more complex environments:

  • Global Fallbacks: When optimizing high-dimensional dynamical systems where geometric boundary calculations become intractable, frameworks like GoSafeOpt (Sukhija et al.) passively learn backup policies. If the GP safety model indicates that a proposed exploratory step risks wandering too close to danger, the system triggers the fallback mechanism to steer the agent back to safety.
  • Non-Gaussian Environments: To handle skewed or heavy-tailed noise models common in industrial applications, the authors of recent work have integrated scenario programming with GP surrogates (Tokmak et al.) or performed robust optimization within the latent space of warped Gaussian processes (Wiebe et al.), preserving rigorous safety bounds even when the underlying data distributions are highly non-Gaussian.

Key Foundational Work

Gaussian Processes in Reinforcement Learning (2003) — contributed 1 concept elements to this direction.
Multivariate Bandits and Their Applications (2010) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_probabilistic_safety_modeling_484e383f,
  title = {probabilistic safety modeling},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/probabilistic-safety-modeling/rdr_484e383ff079482d83a6b21f22f11dec},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-22},
}

This exact version (version 1, frozen text):

@misc{lacuna_probabilistic_safety_modeling_484e383f_v1,
  title = {probabilistic safety modeling},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/probabilistic-safety-modeling/rdr_484e383ff079482d83a6b21f22f11dec/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-22},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake