Safe Bayesian Optimization for Complex Control Systems via Additive Gaussian Processes

## Abstract

Abstract Controller tuning and optimization have been among the most fundamental problems in robotics and mechatronic systems. The traditional methodology is usually model-based, but its performance heavily relies on an accurate mathematical model of the system. In control applications with complex dynamics, obtaining a precise model is often challenging, leading us towards a data-driven approach. While optimizing a single controller has been explored by various researchers, it remains a challenge to obtain the optimal controller parameters safely and efficiently when multiple controllers are involved. In this paper, we propose a high-dimensional safe Bayesian optimization method based on additive Gaussian processes to optimize multiple controllers simultaneously and safely. Additive Gaussian kernels replace the traditional squared-exponential kernels or Matérn kernels, enhancing the efficiency with which Gaussian processes update information on unknown functions. Experimental results on a permanent magnet synchronous motor (PMSM) demonstrate that compared to existing safe Bayesian optimization algorithms, our method can obtain optimal parameters more efficiently while ensuring safety.

## 1 Introduction

Optimizing the controller parameters of complex systems involving multiple controllers is a challenging task. This includes the cascade feedback control architecture typically adopted in motor control, as well as advanced controllers involving feedforward, disturbance observer (DOB) (Jung and Oh, ), and active disturbance rejection control (ADRC) (Cao et al., ), among others. For instance, in the case of permanent magnet synchronous motor (PMSM) control, field-oriented control (FOC) is commonly employed (Gabriel et al., ; Lara et al., ; Wang et al., ). The closed-loop configuration of FOC incorporates three independent proportional-integral (PI) controllers, each with two separate control gains. These six gains require simultaneous adjustment to obtain the optimal parameter combination that enhances control performance. Each adjustment of the parameter combination requires an evaluation process lasting several minutes and also demands extensive experience from a control engineer. Therefore, an efficient and automatic optimization approach using machine learning is needed.

Traditional automatic tuning and optimization methods rely on simplified reduced-order models with assumptions such as linearity. These assumptions, along with modeling errors, often lead to suboptimal performance of controllers in real-world systems (Berkenkamp et al., ). Meanwhile, motion data from real-world systems operating under suboptimal conditions often contain valuable information that traditional model-based methods fail to fully exploit. Data-driven control optimization addresses this limitation by directly leveraging the information in the motion data to optimize controller parameters. It typically models the system’s performance as a function of controller parameters and then explores the optimal parameter iteratively. In this line of research, various algorithms have been designed, with gradient-based algorithms being among the most popular approaches; however, they require accurate gradient estimations (Li et al., ), which can be challenging to obtain with noisy experimental measurements and often lead to convergence at local optima. Additionally, genetic algorithms typically involve extensive testing, making them impractical for real-world applications (Davidor, ).

Bayesian optimization (BO) (Mockus, ) was introduced to address these limitations by modeling the system’s performance function using a Gaussian process (GP) (Rasmussen and Williams, ). In this framework, each controller parameter combination is associated with a performance value represented by a Gaussian distribution, which includes noise measurements. Srinivas et al. () demonstrated that BO methods can converge to the global optimum of unknown performance functions in fewer steps compared to genetic algorithms. However, the BO procedure iteratively tests parameters with the highest uncertainty, often evaluating potentially unsafe controller parameters, which may lead to system instability. Therefore, controller optimization requires the use of a safety-aware BO algorithm, and some representative related work is introduced as follows.

##### Related work.

The SafeOpt (Sui et al., ) and StageOpt (Sui et al., ) algorithms first address the safety concerns of the BO method. They introduce the safe set to avoid evaluating controller parameters whose safety function values fall below a safety threshold, thereby ensuring safety. Berkenkamp et al. () applied SafeOpt to quadrotor controller tuning, validating SafeOpt’s practical effectiveness. However, SafeOpt uses Gaussian kernels or Matérn kernels as the covariance function of the Gaussian processes, which is effective only for low-dimensional problems. Thus, experiments in Berkenkamp et al. () optimize the $x$, $y$, and $z$-axis PI controllers of the quadrotor separately, and each controller has two parameters. Likewise, Fiducioso et al. () added contextual constraints to SafeOpt and only automated the tuning of two parameters for a room temperature controller in a simulator. Additionally, SafeOpt uses the maximum uncertainty sampling acquisition function to balance exploration and exploitation, which causes the evaluated objective function values to fluctuate and not converge. In real control problems, since the optimal solution is unknown, the exact regret cannot be calculated, making it hard to confirm that SafeOpt has obtained the optimal value of the objective function. Although the stage-wise algorithm (Sui et al., ) ensures the convergence of the optimization stage, it still does not improve the efficiency in high dimensions.

Djolonga et al. () assumed that high-dimensional problems could be decomposed into several lower-dimensional subspace optimization problems. Following this, Kirschner et al. () proposed the LINEBO algorithm, claimed as the first and currently the only safe BO algorithm applied to high-dimensional problems. LINEBO decomposes the high-dimensional space into multiple one-dimensional subspaces for safe BO in each subspace, which often requires hundreds or even more than a thousand iterations to find the optimal solution. It is feasible for general optimization problems where performance evaluation can be easily computed in simulation but less feasible for optimizations that involve real-world experiments, such as our control problems.

Two main differences exist between control optimization and the general optimization problems addressed in LINEBO (Kirschner et al., ), making it less effective for high-dimensional control optimization problems. First, the number of parameters in control optimization is commonly between 6 and 10. For example, the electric motor FOC control system is a cascade loop with three PI controllers and six parameters (Gabriel et al., ; Lara et al., ; Wang et al., ); the quadrotor system has three axes with a total of six control parameters, and sometimes twelve parameters if angle control is considered (Berkenkamp et al., ; Yuan et al., ); the gantry system used in industrial automation is a cascade system consisting of three axes, each with an outer loop P controller and an inner loop PI controller, so there are a total of six or nine parameters (Rothfuss et al., ; Wang et al., , ). The problems studied in Kirschner et al. () have 10 to 100 parameters, so the problem scale is different. Second, after each iteration, the controller parameters are applied to the real system to obtain performance and safety evaluations, which usually takes a certain amount of time (ranging from several minutes to tens of minutes). Additionally, the wear on the real system accompanies each evaluation. Therefore, too many iterations are not acceptable in our problem. In contrast, the optimization problems studied in Kirschner et al. () generally do not involve actual experiments, allowing for hundreds or even thousands of iterations. Hence, a safe optimization algorithm with higher efficiency in high-dimensional control problems is needed.

According to Bengio et al. (), the locality of Gaussian kernels prevents GP models from capturing non-local structures. Then Duvenaud et al. () introduced additive Gaussian processes, creating a high-dimensional additive structure for Gaussian kernels, significantly improving the Gaussian process’s capability to model high-dimensional unknown functions. Rolland et al. (); Kandasamy et al. (); Mutny and Krause () demonstrate that additive Gaussian processes have higher efficiency in high-dimensional Bayesian optimization. However, experimental validation involving hardware is limited, and its combination with safety constraints has not been theoretically proved and experimentally validated.

##### Our contributions.

Given the traits of multi-parameter complex control systems, our main contributions in this work are threefold: $1)$ We employ high-dimensional additive structures to Gaussian kernels and utilize a stagewise iteration strategy to develop a novel safe Bayesian optimization method specifically designed for high-dimensional control optimization. The convergence of the proposed method is ensured by theoretical analysis. $2)$ Comprehensive simulation experiments are conducted using FOC with six control gains, demonstrating that the proposed method surpasses traditional frequency response-based methods and conventional safe Bayesian optimization algorithms in terms of control performance and efficiency. $3)$ Real-time experiments for optimizing PMSM controller parameters are executed using the Speedgoat real-time machine, thereby validating the practical applicability of the proposed method.

## 2 Problem statement

The safe optimization problem for complex cascade systems is considered. Cascade systems have multiple controllers, and the output of the outer loop controller serves as the input of the inner loop controller. Consider the discrete-time proportional-integral (PI) control law:

$$ $u_{k}=k_{p}\cdot(y_{k}-r_{k})+k_{i}\cdot\sum_{t=0}^{k}(y_{k}-r_{k}),$ (1) $$

where $u_{k}$ is the control action in time step $k$, $y_{k}$ is the plant output, $r_{k}$ is the reference signal, and $(k_{p},k_{i})$ are the control gains. In a 2-layer cascade system (Figure 1), the control laws for both layers will be:

$$ $u_{k}^{in}=k_{p}^{in}\cdot(y_{k}^{in}-u_{k}^{out})+k_{i}^{in}\cdot\sum_{t=0}^{ k}(y_{k}^{in}-u_{k}^{out}),$ (2) $$

$$ $u_{k}^{out}=k_{p}^{out}\cdot(y_{k}^{out}-r_{k})+k_{i}^{out}\cdot\sum_{t=0}^{k} (y_{k}^{out}-r_{k}).$ (3) $$

In a general form, denote the outermost layer as layer 0 0, and the $n$th inner layer as layer $n$, then the control action $u_{k}$ in layer $n$ is a function of the plant output $y_{k}$ in all layers from layer 0 0 to layer $n$, the reference signal $r_{k}$, and the controller parameters $a$:

$$ $u_{k}^{n}=g((y_{k}^{0},y_{k}^{1},...,y_{k}^{n}),r_{k},a),$ (4) $$

where $a\in\mathbf{A}$, and $\mathbf{A}$ is the domain for possible controller parameters. The controller’s performance measure depends on how well it accomplishes its objective. Instead of modeling complex systems, performance measurement is modeled as a function of controller parameters, $J(a):\mathbf{A}\longmapsto\mathbb{R}$, and all constraints are modeled as functions of controller parameters, $G(a):\mathbf{A}\longmapsto\mathbb{R}$. Both $J(a)$ and $G(a)$ are evaluated on the systems, using cost functions such as Integral Square Error (ISE), Integral Absolute Error (IAE), or Integral Time-weighted Absolute Error (ITAE).

We are to solve a sequential decision problem that finds $a$ maximizing $J(a)$ while making all $G(a)$ satisfy the constraints. Safety considerations are included in $G(a)$. With the assumption that an initial safe controller and its performance, $(a_{0},J(a_{0}))$, is available, a sequence of parameters $a_{1},a_{2},...,a_{n}\in\mathbf{A}$ are selected, and the noisy performance measurement $J(a_{n})+d_{n}$ is obtained after each selection. During the evaluation, $G(a_{n})\geq 0$ must hold with high probability for all $G(a_{n})$, where 0 0 is chosen without loss of generality. In control applications, it is usually desired to find the optimal controller parameters that lead to faster transient response and less amount of overshoot and steady-state error, while ensuring that each physical quantity (such as current, voltage, and power) remains within a safe range during the evaluations, and that the system remains stable at all times.

Figure: Figure 1: A block diagram for a 2-layer cascade system. The dark grey blocks represent controllers, and the light grey blocks represent plants.
Refer to caption: x1.png

## 3 Additive Gaussian processes-based safe Bayesian optimization

### 3.1 Safe Bayesian optimization

Bayesian optimization uses the Gaussian processes to approximate unknown objective functions. By defining an appropriate covariance function $k(\textbf{a}_{i},\textbf{a}_{j})$, the Gaussian processes can combine past observations to predict the mean and variance of the value of the objective function at unobserved points:

$$ $\mu_{n}(\textbf{a})=\textbf{k}_{n}(\textbf{a})(\textbf{K}_{n}+\textbf{I}_{n} \sigma_{\omega}^{2})^{-1}\tilde{\textbf{J}}_{n},\quad\sigma_{n}^{2}(\textbf{a} )=k(\textbf{a},\textbf{a})-\textbf{k}_{n}(\textbf{a})(\textbf{K}_{n}+\textbf{I }_{n}\sigma_{\omega}^{2})^{-1}\textbf{k}_{n}^{T}(\textbf{a}),$ (5) $$

where $\tilde{\textbf{J}}_{n}=[\tilde{J}(\textbf{a}_{1}),...,\tilde{J}(\textbf{a}_{n}
)]^{T}$ is the vector of noisy performance measurements, the matrix $\textbf{K}_{n}$ has entries $[\textbf{K}_{n}]_{(i,j)}=k(\textbf{a}_{i},\textbf{a}_{j})$, and the vector $\textbf{k}_{n}(\textbf{a})=[k(\textbf{a},\textbf{a}_{1}),...,k(\textbf{a},
\textbf{a}_{n})]$. $k(\textbf{a}_{i},\textbf{a}_{j})$ is also called the kernel of the Gaussian processes.

Through the mean and variance of the value of the unknown function at each point, the upper and lower bounds of the confidence interval can be calculated:

$$ $u_{n}(\textbf{a})=\mu_{n-1}(\textbf{a})+\beta_{n}\sigma_{n-1}(\textbf{a}), \quad l_{n}(\textbf{a})=\mu_{n-1}(\textbf{a})-\beta_{n}\sigma_{n-1}(\textbf{a}),$ (6) $$

where $\beta_{n}$ is a variable defining the confidence interval. Previous safe Bayesian optimization algorithms, such as SafeOpt (Sui et al., ; Berkenkamp et al., ), use the upper and lower bounds of the confidence interval to define safe sets $S_{n}$, which contain all the parameters a that have high probabilities of getting the values of safety functions $g_{i}$ above the safe thresholds $h_{i}$; and sets of potential maximizers $M_{n}$, which contain a that could obtain the optimum of the performance function $j$; and sets of potential expanders $E_{n}$, which contain a that could be recognized as safe after a new iteration. We relax the Lipschitz constants $L$ in the expressions of $S_{n}$, $M_{n}$, and $E_{n}$ for ease of implementation, and show them in Algorithm 1. By limiting the points selected for evaluation in each iteration to $S_{n}$, previous safe Bayesian optimization algorithms ensure that the iteration process has a high probability of not violating safety constraints. The selection at each iteration follows different acquisition functions, such as the GP-UCB method (Srinivas et al., ), or the modified UCB method (hereinafter referred to as "UCB-LCB") proposed by Berkenkamp et al. ():

$$ $\textbf{a}_{n}=argmax_{a\in E_{n}\cup M_{n}}w_{n}(\textbf{a}),\quad w_{n}( \textbf{a})=u_{n}(\textbf{a})-l_{n}(\textbf{a}).$ (7) $$

### 3.2 Additive Gaussian processes

Despite various improvements for high-dimensional problems, such as the SwarmSafeOpt algorithm used in Berkenkamp et al. () and the LINEBO algorithm (Kirschner et al., ), the squared-exponential (Gaussian) kernels used in these work have limited information acquisition ability in the parameter space. Therefore, we built upon the idea from additive Gaussian processes (Duvenaud et al., ), implementing high-dimensional additive structures to the original Gaussian kernels, to obtain a higher information acquisition efficiency.

The high-dimensional additive kernels for each order are the sums of combinations of base kernels, and the base kernels are one-dimensional Gaussian kernels, $k(\textbf{a}_{i},\textbf{a}_{j})$. Denote $z_{i}$ to be the base kernel for the $i\textsuperscript{th}$ dimension, then additive kernels for different orders can be designed:

$$ $\displaystyle k_{add_{1}}(\textbf{a},\textbf{a}^{\prime})$ $\displaystyle=\sum_{i=1}^{D}z_{i}=z_{1}+z_{2}+\dots+z_{D},$ (8) $\displaystyle k_{add_{2}}(\textbf{a},\textbf{a}^{\prime})$ $\displaystyle=\sum_{i=1}^{D-1}\sum_{j=i+1}^{D}z_{i}z_{j}=z_{1}z_{2}+z_{1}z_{3} +\dots+z_{1}z_{D}+z_{2}z_{3}+\dots+z_{D-1}z_{D},$ (9) $\displaystyle k_{add_{n}}(\textbf{a},\textbf{a}^{\prime})$ $\displaystyle=\sum_{1\leq i_{1}<i_{2}<\ldots<i_{n}\leq D}\prod_{d=1}^{N}z_{i_{ d}}$ (10) $$

The complete stagewise optimization procedure is shown in Algorithm 1. The full additive kernel applied in the proposed algorithm is the sum of the additive kernels of all orders. The UCB-LCB method is used in the exploration stage (line $6$), and the GP-UCB method is used in the exploitation stage (line $13$). Since the exploration stage does not involve the optimization of the maximum value of the objective function, there is no need to calculate the potential maximizer set $M_{n}$ at this stage. Similarly, calculating the potential expander set $E_{n}$ is avoided in the optimization phase.

Figure: Algorithm 1 Additive Gaussian Processes-based Safe Bayesian Optimization

### 3.3 Theoretical results

The convergence of previous safe BO algorithms (Sui et al., , ) are guaranteed based on two assumptions: by choosing some common Gaussian kernels, $(1)$ the performance function $f$ and safety functions $g_{i}$ have bounded norms in their Reproducing Kernel Hilbert Spaces (RKHS) associated with the GPs, and $(2)$ the safety functions are Lipschitz-continuous. We will prove that the additive Gaussian kernel composed of the one-dimensional Gaussian kernels that satisfy the two assumptions can also make the objective function satisfy the two assumptions. Therefore, the convergence of the proposed method will naturally conform to previous safe BO algorithms.

###### Lemma 1 .

The Reproducing Kernel Hilbert Space (RKHS) $\mathcal{H}$ corresponding to the additive Gaussian kernel $K$ composed of one-dimensional Gaussian kernels $K_{i}$ is a complete inner product space composed of the direct sum of the RKHSs corresponding to each one-dimensional Gaussian kernel, and the additive Gaussian kernel $K$ is a positive definite kernel function, which conforms to the properties of the reproducing kernel.

Lemma 1 proves the existence of RKHS for the additive Gaussian kernel composed of the one-dimensional Gaussian kernels that satisfy the two assumptions. The complete proof of Lemma 1 is presented in Appendix A.3.1. The main idea is to prove that the additive Gaussian kernel $K$ is a positive definite kernel function, and its corresponding RKHS $\mathcal{H}$ has a complete inner product structure and satisfies the reproducing property.

###### Theorem 1 .

If the norm of a function $f$ is bounded by $B_{i}$ in each of the RKHSs corresponding to the one-dimensional Gaussian kernels $K_{i}$, $i\in\{1,2,\dots,d\}$, then the norm of $f$ is bounded by $B$ in the RKHS associated with the additive Gaussian kernel $K$ composed of $K_{i}$, where $B=\sum_{i=1}^{d}B_{i}$.

Based on Lemma 1, Theorem 1 makes our method satisfy assumption $(1)$. It is proved by demonstrating that the norm of $f$ in the RKHS $\mathcal{H}$ of the additive Gaussian kernel is the sum of its norms in the individual RKHSs $\mathcal{H}_{i}$ of the one-dimensional Gaussian kernels, ensuring the overall boundedness. The complete proof of Theorem 1 is presented in Appendix A.3.2.

###### Theorem 2 .

If all the one-dimensional Gaussian kernels $K_{i}$ that constitute the additive Gaussian kernel $K$ are $L_{i}$-Lipschitz-continuous, then the additive Gaussian kernel $K$ satisfies $L$-Lipschitz continuity, where $L=\left(\sum_{i=1}^{d}L_{i}\right)\sqrt{d}$.

Theorem 2 makes our method satisfy assumption $(2)$. Given the properties of Lipschitz continuity for each $K_{i}$, theorem 2 is proved by demonstrating that the sum of these Lipschitz continuous functions, $K$, retains the Lipschitz property with a constant $L$, that is the sum of the individual $L_{i}$. The complete proof of Theorem 2 is presented in Appendix A.3.3.

###### Lemma 1 .

###### Theorem 1 .

###### Theorem 2 .

##### Discussion.

As the two assumptions are proved satisfied by the additive Gaussian kernel composed of the one-dimensional Gaussian kernels that satisfy the two assumptions, the convergence of the proposed method is guaranteed. Besides, BO’s computational complexity is dominated by calculating the mean and covariance of the Gaussian process (Eq. 5), so the complexity is $O(n^{3})$ for both the proposed method and the previous safe BO method. In the next section, we show by experiments that the proposed method is more efficient in obtaining the optimum for high-dimensional control problems.

## 4 Experiments

The efficacy of the proposed algorithm (hereafter referred to as "our method") is validated on a PMSM. The architecture of the FOC scheme is depicted in Figure 2, which comprises a cascade control loop. The external controller is a speed controller responsible for regulating the motor’s rotational speed. The internal controllers consist of two current controllers that manage the current output from the inverter. These three controllers are interdependent, so the simultaneous adjustment of the six parameters across all controllers is essential to obtain the optimal parameter combination.

Figure: Figure 2: A simplified block diagram for PMSM FOC loops. The dark grey blocks represent controllers, and the light grey blocks represent plants.
Refer to caption: x2.png

### 4.1 Simulations in Simulink

In this section, the simulation employs FOC for a PMSM, modeled in Simulink using Simscape Electrical components(^1^11https://www.mathworks.com/help/slcontrol/ug/tune-field-oriented-controllers-using-systune.html.). The objective is to determine the controller parameters that optimize the speed tracking performance of the PMSM, aiming to maximize transient response speed while minimizing overshoot and steady-state error. This objective is crucial for various industrial applications, including precise robot joint control, industrial automation system control, and electric vehicle control, among others. The transient response of the system is evaluated using the $5\%$ settling time, defined as the duration required for the response curve to reach and remain within $5\%$ of the steady-state value. The performance function is then designed as:

$$ $J(t_{s},O_{s},e_{ss})=w_{s}\cdot(t_{0}-t_{s})-w_{o}\cdot O_{s}-w_{e}\cdot e_{ ss},$ (11) $$

where $w_{s}$, $w_{o}$, and $w_{e}$ are weight factors, $t_{0}$ is a time constant depending on the task, $t_{s}$ is the value of settling time, $O_{s}$ is the value of overshoot, and $e_{ss}$ is the value of steady-state error.

To guarantee safety, the motor system must remain stable, so the steady-state error should be controlled within a narrow range. Additionally, the control signal must be moderated to prevent excessive current, which could potentially damage the motor hardware. To address these concerns, two safety functions have been designed, pertaining to the magnitude of the steady-state error and the amplitude of the control signal:

$$ $G_{e}=C_{e0}-w_{e}^{\prime}\cdot e_{ss},$ (12) $$

$$ $G_{u}=C_{u0}-w_{u}\cdot\sum_{t=0}^{1}u(t)^{2},$ (13) $$

where $C_{e0}$ and $C_{u0}$ are constants defined according to the system characteristics, and $w_{e}^{\prime}$ and $w_{u}$ are weight factors. The safety functions’ minimum thresholds are set at 0 0, indicating that any value below this threshold constitutes a violation of the safety constraints. The parameters predefined in the model serve as the initial settings, and evaluations of these initial settings against the safety functions indicate that their values meet this minimum threshold.

Figure: (a) Speed tracking curves using our method.
Refer to caption: extracted/5820242/Simulation_27_iterations.png

Once the performance and safety functions are defined and the initial controller parameters deemed safe, the experimental process moves forward by seeking the combination of controller parameters that optimizes the performance function through iterations. $\beta_{n}=2$ is used for a $95.4\%$ confidence interval. Given that FOC employs three PI controllers with six control gains, six base kernels are established. These correspond to the proportional (P) and integral (I) gains for the speed controller, the $d$-axis current controller, and the $q$-axis current controller. The six base kernels are combined into six additive kernels, with their sum serving as the kernel for the Bayesian optimization algorithm. The number of exploratory iterations is capped at $15$, beyond which the safety set is fixed, transitioning all subsequent iterations to exploitation mode.

Parameter selections for each iteration are documented and presented in the Appendix A. The simulation results are shown in Figure 3(a). Our method identifies the optimal controller parameter combination in the $16\textsuperscript{th}$ iteration and maintains stability near this optimal curve in subsequent iterations (Figure 3(a)). The red curve in Figure 3(d) illustrates the performance function’s progression during optimization with our method, peaking at the $16\textsuperscript{th}$ iteration. Thereafter, the performance function values slightly decline from this peak, yet remain higher than the initial values. The red curves in Figures 3(e) and 3(f) show the function value changes of the two safety functions. All parameter combinations evaluated by our method meet the minimum safety threshold, confirming that the optimization process adheres to safety constraints.

The frequency response-based tuning method, Systune in MATLAB, serves as a baseline for comparison, represented by the yellow curve in Figure 4(a). The red curve illustrates the speed tracking curve optimized by our method, demonstrating a comparable transient response speed and zero steady-state error without any overshoot, outperforming the curve achieved by Systune.

Figure: (a) Comparison with Systune.
Refer to caption: extracted/5820242/Simulation_comparision_systune.png

We maintain fixed performance and safety functions, employing SwarmSafeOpt and SwarmStageOpt (hereinafter referred to as SafeOpt and StageOpt, respectively) to adjust the controller parameters of the same PMSM model. The simulation results are depicted in Figures 3(b) and 3(c), with both methods undergoing $50$ iterations. The red curves in these figures represent the tracking curves of the optimal controllers identified by each method after $50$ iterations. Figure 4(b) compares the speed tracking curves of the best controllers optimized using our method, SafeOpt, and StageOpt algorithms. Observations indicate that SafeOpt exhibits a slower transient response with significant overshoot, whereas the StageOpt-tuned controller demonstrates a rapid transient response but includes a slight undershoot. Compared with StageOpt, our method has more efficient information update capabilities in the exploration phase, thus it can complete the exploration of the safe set with fewer iterations, and obtain the optimal parameter combination during exploitation. In terms of safety, according to Figures 3(e) and 3(f), all three algorithms largely avoid unsafe parameter combinations, with our method and StageOpt exhibiting comparatively better performance.

### 4.2 Experiments with Speedgoat real-time machine

In this section, real-time experiments are conducted using the Speedgoat machine, shown in Figure 5. The configuration includes a controller with integrated speed and current loops, an inverter, and a PMSM. The control algorithm within the controller is adjustable via MATLAB. The transient response of the system is assessed using $5\%$ settling time, and the performance function and two safety functions are designed as described in section 4.1.

Figure: Figure 5: Real-time experimental setup.
Refer to caption: extracted/5820242/SetUp.png

We use the default parameters in Speedgoat to build the initial controller, and evaluations confirm that both safety functions meet the minimum thresholds. The initial speed tracking result is represented by the green curve in Figure 6(a). The proposed Algorithm 1 is employed to optimize the controller parameters. The configuration of the six base kernels is consistent with those detailed in section 4.1, and the exploration phase is designed to last for $15$ iterations. After the $35\textsuperscript{th}$ iteration, our method obtains the optimal controller parameter combination, as depicted by the red curve in Figure 6(a). Figure 6(b) illustrates the changes in the performance function, which stabilizes around the final values post-$35$ iterations. Figures 6(c) and 6(d) display the changes in the safety function values. Observations indicate that the values of the safety functions for the parameter combinations assessed by our method are almost all above the minimum threshold, suggesting that the optimization process adheres to safety constraints.

It is also pertinent to note that the result from the $40\textsuperscript{th}$ iteration (illustrated by the purple curve in Figure 6(a)) demonstrates a higher performance value than that of the $35\textsuperscript{th}$ iteration, featuring a faster transient response with negligible overshoot and steady-state error. This is an interesting and non-intuitive result, as control engineers typically tune the system performance to resemble the red curve without the vibration in the purple curve. In certain applications, such as industrial high-throughput semiconductor packaging systems, slight vibrations are acceptable as long as the settling time is reduced. However, in other applications, such as inspection systems, vibrations can result in blurry images, which is unacceptable. Therefore, the performance achieved in the $40\textsuperscript{th}$ iteration could potentially lead to further performance enhancements in specific applications.

Figure: (a) Speed tracking curves.
Refer to caption: extracted/5820242/real-time_motor_experiment.png

## 5 Conclusions

In this study, we propose to replace traditional Gaussian kernels or Matérn kernels with high-dimensional additive Gaussian kernels, enabling the application of safe Bayesian optimization to high-dimensional complex control systems. The additive Gaussian kernels are more efficient in exploring high-dimensional space information, accomplishing the exploration of the safe set in fewer iterations. We verified the effectiveness of the proposed method for PMSM control in both simulation and real-time experiments. The results indicate that our proposed method surpasses existing safe Bayesian optimization algorithms in high-dimensional control system optimization and can be seamlessly integrated into real-world industrial control applications. Although tested only for PMSM control, the proposed algorithm is potentially applicable to other types of control architecture, as well as to other robotic and mechatronic systems, since it is designed for a general dynamical system.

However, the limitation of the work is that the calculations of high-dimensional additive Gaussian kernels become more complex when the dimensions of the control problems get higher. The calculation of Eq. 10 usually takes a long time and even causes the program to crash when the dimension is higher than $10$. A possible solution is to use kernel selection methods (Cristianini et al., ; Kandola et al., ; Ding et al., ) to obtain one or more additive Gaussian kernels with the highest efficiency in exploring the parameter space, and use the selected kernels for subsequent optimization.

## Acknowledgments and Disclosure of Funding

This work was supported by RIE2025 Manufacturing, Trade and Connectivity (MTC) Industry Alignment Fund – Pre-Positioning (IAF-PP) under Grant M22K4a0044 through WP3-Energy Efficient Motor Drive System with GaN-based Traction Inverters.

## Appendix A Appendix

### A.1 Implementation details of simulations

For all simulations implemented in the work, the performance functions are chosen to be:

$$ $J=20\cdot(1-t_{s})-1.2\cdot O_{s}-4\cdot e_{ss},$ (14) $$

and the safety constraint functions are chosen to be:

$$ $G_{e}=100-40\cdot e_{ss},$ (15) $$

$$ $G_{u}=100-0.001\cdot\sum_{t=0}^{1}u(t)^{2},$ (16) $$

**Table 1: Intermediate experimental data in simulation using our method. $v_{p}$ and $v_{i}$ represent the proportional (P) and integral (I) gains of the speed controller, $d_{p}$ and $d_{i}$ represent the P and I gains of the $d$-axis current controller, and $q_{p}$ and $q_{i}$ represent the P and I gains of the $q$-axis current controller. "SS Error" represents steady-state error, and "Safety" represents control signal safety.**
| # | $v_{p}$ | $v_{i}$ | $d_{p}$ | $d_{i}$ | $q_{p}$ | $q_{i}$ | Performance | SS Error | Safety | Phase |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 0.0866 | 0.1997 | 1 | 100 | 1 | 100 | 1.1625 | 47.2696 | 96.0406 | Initial |
| 1 | 0.05 | 0.05 | 2.7426 | 164.2602 | 1.2276 | 83.4686 | -0.8417 | 24.9132 | 97.8294 | Exploration |
| 2 | 0.1973 | 0.3242 | 0.5 | 18.007 | 0.5 | 150.6434 | 4.0003 | 72.4438 | 89.5705 | Exploration |
| 3 | 0.4527 | 0.05 | 0.5 | 35.8284 | 3.8852 | 132.6675 | -9.3715 | 94.2007 | 42.7651 | Exploration |
| 4 | 0.3724 | 0.05 | 0.5 | 1 | 3.9795 | 47.8125 | 8.2602 | 94.5904 | 64.4529 | Exploration |
| 5 | 0.5213 | 0.6274 | 0.5 | 1 | 3.8557 | 113.029 | -12.0279 | 91.6761 | 21.3731 | Exploration |
| 6 | 0.3292 | 0.6566 | 0.5 | 1 | 3.4119 | 60.5823 | 1.5574 | 87.0628 | 70.7045 | Exploration |
| 7 | 0.7588 | 0.6032 | 0.5 | 1 | 5 | 65.7199 | -2.1553 | 96.1554 | 0.4184 | Exploration |
| 8 | 0.6152 | 0.4938 | 0.5 | 2.9722 | 1.3743 | 66.7462 | -22.1333 | 92.6164 | 1.8611 | Exploration |
| 9 | 0.05 | 0.502 | 0.5 | 7.7606 | 5 | 83.6086 | -18.6389 | 97.7827 | 96.8129 | Exploration |
| 10 | 0.3532 | 0.5889 | 0.6216 | 6.0938 | 5 | 1 | 13.8638 | 74.0942 | 66.9749 | Exploration |
| 11 | 0.4921 | 0.5562 | 0.5 | 1 | 1.0084 | 35.491 | -9.954 | 87.6243 | 30.4906 | Exploration |
| 12 | 0.4897 | 0.8781 | 0.5 | 1 | 0.5 | 48.0767 | -27.124 | 89.617 | 21.0177 | Exploration |
| 13 | 0.5875 | 0.8666 | 0.5 | 38.375 | 0.5 | 1 | 8.8413 | 24.1905 | 2.4484 | Exploration |
| 14 | 0.3251 | 0.3746 | 2.7426 | 200 | 5 | 200 | -6.1221 | 84.6313 | 71.1914 | Exploration |
| 15 | 0.5529 | 0.05 | 0.5 | 148.6101 | 0.5 | 200 | -48.1679 | 94.9213 | 5.1146 | Exploration |
| 16 | 0.4428 | 0.3997 | 5 | 73.0644 | 3.0365 | 1 | 16.5812 | 86.0938 | 49.0642 | Exploitation |
| 17 | 0.3552 | 1 | 4.2471 | 100.8284 | 5 | 4.6037 | 11.42 | 76.9631 | 66.1546 | Exploitation |
| 18 | 0.5182 | 1 | 1.8977 | 184.8673 | 3.3018 | 1 | 13.118 | 72.3136 | 29.4682 | Exploitation |
| 19 | 0.648 | 0.05 | 2.5244 | 84.1685 | 5 | 1 | 16.2378 | 79.1777 | 4.5874 | Exploitation |
| 20 | 0.575 | 1 | 3.7071 | 1 | 2.6024 | 1 | 13.4296 | 70.2912 | 13.531 | Exploitation |
| 21 | 0.5899 | 0.5973 | 5 | 200 | 5 | 1 | 14.4016 | 72.7052 | 11.4404 | Exploitation |
| 22 | 0.3203 | 0.05 | 5 | 1 | 5 | 1 | 13.0091 | 48.6909 | 73.5805 | Exploitation |
| 23 | 0.1479 | 0.3583 | 5 | 100.8284 | 4.8868 | 121.2693 | 7.5323 | 73.0876 | 93.4058 | Exploitation |
| 24 | 0.5551 | 0.2655 | 2.7426 | 25.1938 | 0.5303 | 1 | 15.3491 | 80.2425 | 12.1234 | Exploitation |
| 25 | 0.5898 | 0.05 | 3.9055 | 200 | 3.2466 | 1 | 14.8883 | 65.8826 | 12.9564 | Exploitation |
| 26 | 0.3421 | 0.2398 | 0.5 | 200 | 5 | 1 | 16.422 | 96.8881 | 69.6904 | Exploitation |
| 27 | 0.5618 | 0.4595 | 0.5 | 162.2527 | 2.4238 | 1 | 16.3594 | 83.9042 | 18.8431 | Exploitation |

**Table 2: Intermediate experimental data in simulation using SafeOpt. $v_{p}$ and $v_{i}$ represent the proportional (P) and integral (I) gains of the speed controller, $d_{p}$ and $d_{i}$ represent the P and I gains of the $d$-axis current controller, and $q_{p}$ and $q_{i}$ represent the P and I gains of the $q$-axis current controller. "SS Error" represents steady-state error, and "Safety" represents control signal safety.**
| # | $v_{p}$ | $v_{i}$ | $d_{p}$ | $d_{i}$ | $q_{p}$ | $q_{i}$ | Performance | SS Error | Safety |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 0.0866 | 0.1997 | 1 | 100 | 1 | 100 | 1.1625 | 47.2696 | 96.0406 |
| 1 | 0.2125 | 0.05 | 0.5431 | 198.5069 | 0.5 | 59.295 | 6.3517 | 98.6637 | 87.3151 |
| 2 | 0.1657 | 0.0561 | 2.0418 | 129.0444 | 0.9933 | 1.6072 | 4.2488 | 32.4878 | 85.6754 |
| 3 | 0.2568 | 0.05 | 0.8337 | 177.3595 | 0.5 | 15.9028 | 6.9854 | 99.9493 | 79.0969 |
| 4 | 0.05 | 0.05 | 1.0244 | 172.235 | 0.5 | 36.0666 | -4.228 | -44.2163 | 97.3405 |
| 5 | 0.5658 | 0.0813 | 0.5 | 131.8195 | 0.5461 | 64.5804 | -37.7207 | 96.7198 | -10.0486 |
| 6 | 0.4621 | 0.196 | 0.5 | 200 | 0.5 | 27.7024 | -12.9554 | 93.3831 | 38.1369 |
| 7 | 0.2409 | 0.05 | 0.5 | 200 | 1.6737 | 1 | 3.3834 | -37.1659 | 81.4885 |
| 8 | 0.149 | 0.05 | 0.5 | 200 | 0.5 | 1 | -4.385 | 1.15 | 77.2812 |
| 9 | 0.0751 | 0.2274 | 0.5 | 200 | 2.2937 | 102.7851 | -2.5929 | 62.0975 | 96.6301 |
| 10 | 0.3638 | 0.05 | 2.1236 | 200 | 0.5 | 20.3252 | 1.7528 | 95.5355 | 64.3375 |
| 11 | 0.1951 | 0.05 | 0.5 | 200 | 0.5 | 95.0849 | 10.4506 | 99.3915 | 89.7755 |
| 12 | 0.1315 | 0.05 | 0.5 | 200 | 0.5 | 123.8552 | 16.045 | 88.53 | 94.1008 |
| 13 | 0.05 | 0.05 | 0.5 | 200 | 0.5 | 155.2546 | 0.2046 | -17.5949 | 97.9724 |
| 14 | 0.05 | 0.05 | 0.5 | 200 | 0.5 | 110.7776 | -0.2578 | -20.7361 | 97.8814 |
| 15 | 0.3291 | 0.05 | 0.5 | 200 | 0.5 | 153.2459 | -0.2578 | -20.7361 | 97.8814 |
| 16 | 0.1913 | 0.05 | 1.0275 | 200 | 0.5 | 124.3872 | 12.6599 | 99.2748 | 90.4323 |
| 17 | 0.05 | 0.05 | 0.5 | 200 | 2.0418 | 115.1973 | -0.138 | -18.7345 | 97.9467 |
| 18 | 0.3755 | 0.05 | 0.5 | 169.1539 | 1.4623 | 40.2015 | 0.9763 | 94.7654 | 62.8288 |
| 19 | 0.3829 | 0.1331 | 0.5 | 200 | 0.5 | 1 | 13.4465 | 93.4646 | 48.8848 |
| 20 | 0.1027 | 0.05 | 0.5 | 200 | 0.8783 | 137.9869 | 14.2109 | 74.0152 | 95.7179 |
| 21 | 0.4718 | 0.1547 | 0.6127 | 200 | 0.5 | 44.6108 | -24.7576 | 97.4063 | 30.3786 |
| 22 | 0.1505 | 0.05 | 2.0418 | 200 | 0.6102 | 133.3287 | 16.1159 | 93.6419 | 93.2439 |
| 23 | 0.2032 | 0.05 | 0.5 | 200 | 0.5 | 126.5817 | 9.0935 | 98.4063 | 89.3381 |
| 24 | 0.3849 | 0.05 | 2.0418 | 200 | 0.5 | 185.5526 | -35.1514 | 94.2956 | 53.2408 |
| 25 | 0.1463 | 0.05 | 2.1545 | 200 | 0.6141 | 112.7913 | 15.0447 | 92.1961 | 93.2458 |
| 26 | 0.05 | 0.05 | 2.0418 | 200 | 0.5 | 122.6996 | -0.1178 | -20.0967 | 97.9116 |
| 27 | 0.1903 | 0.05 | 2.0418 | 200 | 1.2147 | 106.3331 | 13.3229 | 99.6044 | 90.505 |
| 28 | 0.2252 | 0.0839 | 2.5108 | 200 | 0.8723 | 111.291 | 4.7958 | 93.4421 | 86.7898 |
| 29 | 0.2778 | 0.05 | 1.0768 | 200 | 0.5 | 24.9691 | 4.0711 | 97.1593 | 78.2732 |
| 30 | 0.1379 | 0.3755 | 0.5 | 200 | 0.5 | 136.0519 | 8.2753 | 74.103 | 93.5344 |
| 31 | 0.1671 | 0.0697 | 1.7785 | 200 | 0.5075 | 112.8173 | 13.3791 | 88.9843 | 91.962 |
| 32 | 0.1867 | 0.0727 | 1.2012 | 196.5409 | 0.8618 | 99.2754 | 12.0459 | 90.6551 | 90.7203 |
| 33 | 0.1176 | 0.05 | 1.8399 | 200 | 1.196 | 137.361 | 15.4233 | 83.425 | 95.0803 |
| 34 | 0.1598 | 0.05 | 1.4062 | 200 | 2.0418 | 139.1149 | 15.7745 | 96.0924 | 92.9774 |
| 35 | 0.3707 | 0.05 | 0.5 | 200 | 1.3647 | 200 | -27.1677 | 94.5853 | 58.625 |
| 36 | 0.3126 | 0.05 | 0.7972 | 200 | 0.5 | 109.5319 | -19.6329 | 95.645 | 71.6801 |
| 37 | 0.1367 | 0.05 | 0.5 | 200 | 0.8019 | 124.0215 | 15.8289 | 90.4427 | 93.9604 |
| 38 | 0.21 | 0.0512 | 2.0418 | 200 | 0.5 | 102.5818 | 8.0667 | 97.8118 | 88.5315 |
| 39 | 0.1463 | 0.05 | 1.3332 | 200 | 1.0667 | 112.7913 | 15.1611 | 92.5621 | 93.4554 |
| 40 | 0.1309 | 0.05 | 2.0255 | 200 | 2.2618 | 142.8766 | 15.6458 | 89.3237 | 94.6005 |
| 41 | 0.2191 | 0.05 | 2.7429 | 128.3604 | 0.5 | 31.0949 | 4.9738 | 99.9847 | 84.7412 |
| 42 | 0.3209 | 0.0505 | 2.0418 | 200 | 1.0494 | 24.3286 | 7.7482 | 96.4799 | 73.1308 |
| 43 | 0.2734 | 0.0611 | 0.5 | 200 | 0.5 | 1 | 3.7355 | 37.7546 | 64.1897 |
| 44 | 0.1585 | 0.1091 | 1.6841 | 200 | 2.7194 | 152.2639 | 12.8973 | 74.4094 | 93.0556 |
| 45 | 0.4814 | 0.05 | 1.3968 | 200 | 0.5 | 1 | 10.4935 | 49.1354 | 30.2293 |
| 46 | 0.1665 | 0.05 | 0.5 | 200 | 2.0418 | 100.5435 | 14.9799 | 96.957 | 92.3301 |
| 47 | 0.3043 | 0.05 | 0.5 | 200 | 2.7673 | 60.2396 | 6.7583 | 95.2649 | 76.2315 |
| 48 | 0.2081 | 0.05 | 1.5389 | 200 | 2.495 | 130.8248 | 11.3457 | 98.153 | 88.9105 |
| 49 | 0.2127 | 0.05 | 0.5 | 200 | 1.7229 | 65.7934 | 12.2833 | 98.6934 | 88.1602 |
| 50 | 0.05 | 0.1187 | 2.4957 | 200 | 2.8503 | 167.6624 | -10.7855 | 9.4729 | 97.8802 |

**Table 3: Intermediate experimental data in simulation using StageOpt. $v_{p}$ and $v_{i}$ represent the proportional (P) and integral (I) gains of the speed controller, $d_{p}$ and $d_{i}$ represent the P and I gains of the $d$-axis current controller, and $q_{p}$ and $q_{i}$ represent the P and I gains of the $q$-axis current controller. "SS Error" represents steady-state error, and "Safety" represents control signal safety.**
| # | $v_{p}$ | $v_{i}$ | $d_{p}$ | $d_{i}$ | $q_{p}$ | $q_{i}$ | Performance | SS Error | Safety | Phase |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 0.0866 | 0.1997 | 1 | 100 | 1 | 100 | 1.1625 | 47.2696 | 96.0406 | Initial |
| 1 | 0.0867 | 0.3755 | 2.5422 | 130.9846 | 1.3476 | 9.5802 | -6.9164 | 79.4739 | 93.7998 | Exploration |
| 2 | 0.3755 | 0.1485 | 3.0364 | 56.4987 | 0.5 | 69.1805 | -21.1302 | 95.5378 | 57.5297 | Exploration |
| 3 | 0.0867 | 0.3755 | 2.5422 | 130.9846 | 1.3476 | 9.5802 | -6.9164 | 79.4739 | 93.7998 | Exploration |
| 4 | 0.1339 | 0.3755 | 2.7922 | 70.7126 | 0.5 | 20.9795 | -7.1671 | 70.019 | 89.8821 | Exploration |
| 5 | 0.3755 | 0.05 | 0.5 | 51.9494 | 1.3865 | 1 | 8.1336 | 1.9364 | 60.9649 | Exploration |
| 6 | 0.3497 | 0.0563 | 1.5639 | 127.2999 | 0.5 | 1 | 5.7736 | 37.5362 | 54.2492 | Exploration |
| 7 | 0.0866 | 0.1997 | 1 | 100 | 1 | 100 | 1.1382 | 47.2906 | 96.0382 | Exploration |
| 8 | 0.3755 | 0.05 | 0.9527 | 126.4484 | 0.5317 | 1 | 5.7483 | 29.2828 | 51.5117 | Exploration |
| 9 | 0.2708 | 0.158 | 2.5722 | 93.4898 | 0.5 | 6.965 | 9.2533 | 62.1273 | 74.9119 | Exploration |
| 10 | 0.1913 | 0.7972 | 0.5 | 119.6598 | 0.6065 | 76.7329 | -0.1716 | 93.6394 | 88.8829 | Exploration |
| 11 | 0.3196 | 0.05 | 0.5 | 37.888 | 1.0276 | 1 | 5.0979 | -20.621 | 68.0923 | Exploration |
| 12 | 0.3755 | 0.1485 | 3.0364 | 56.4987 | 0.5 | 69.1805 | -21.1302 | 95.5378 | 57.5297 | Exploration |
| 13 | 0.05 | 0.5442 | 0.5 | 100.0474 | 3.3264 | 45.1144 | -20.9072 | 98.2817 | 96.3663 | Exploration |
| 14 | 0.3755 | 0.05 | 2.6052 | 103.0839 | 0.5 | 1 | 6.1741 | 36.1414 | 50.3281 | Exploration |
| 15 | 0.1196 | 0.05 | 1.8031 | 79.8604 | 0.5 | 1 | -5.7627 | -1.6271 | 80.3405 | Exploration |
| 16 | 0.4652 | 0.0823 | 0.5794 | 84.8569 | 1.1933 | 5.9767 | 15.686 | 94.6812 | 45.1408 | Exploitation |
| 17 | 0.5451 | 0.05 | 0.5 | 77.9733 | 1.0293 | 1 | 9.5393 | 34.1935 | 21.7214 | Exploitation |
| 18 | 0.4434 | 0.08 | 1.0732 | 107.9325 | 1.7036 | 9.1632 | 14.8941 | 96.693 | 50.3744 | Exploitation |
| 19 | 0.3993 | 0.2174 | 0.6129 | 77.274 | 1.3339 | 29.7356 | 1.0916 | 89.4986 | 57.6796 | Exploitation |
| 20 | 0.4099 | 0.05 | 0.5 | 105.4225 | 1.284 | 1 | 8.7803 | 7.8031 | 54.134 | Exploitation |
| 21 | 0.4251 | 0.05 | 1.0048 | 76.5397 | 0.5 | 1 | 8.1512 | 41.7116 | 41.613 | Exploitation |
| 22 | 0.4822 | 0.2214 | 1.3949 | 107.8345 | 1.0681 | 1 | 16.1908 | 81.1078 | 36.9227 | Exploitation |
| 23 | 0.5062 | 0.05 | 1.2914 | 80.7403 | 1.1988 | 1 | 10.9173 | 27.9733 | 32.4501 | Exploitation |
| 24 | 0.5414 | 0.0935 | 0.8686 | 105.2303 | 2.0418 | 1 | 14.187 | 59.2701 | 25.3523 | Exploitation |
| 25 | 0.524 | 0.2281 | 1.0295 | 93.8913 | 1.3316 | 1 | 16.3896 | 81.8958 | 27.9259 | Exploitation |
| 26 | 0.5938 | 0.1431 | 0.6362 | 97.0519 | 1.4062 | 1 | 14.9816 | 67.4155 | 9.3611 | Exploitation |
| 27 | 0.5149 | 0.092 | 1.1074 | 91.9506 | 1.3316 | 10.8292 | 11.3293 | 99.1748 | 32.5445 | Exploitation |
| 28 | 0.4908 | 0.215 | 0.5 | 81.9485 | 0.8389 | 1 | 15.6492 | 86.4923 | 33.2869 | Exploitation |
| 29 | 0.5468 | 0.1971 | 0.5 | 106.6586 | 1.2676 | 1 | 15.8491 | 76.4912 | 21.8263 | Exploitation |
| 30 | 0.3481 | 0.05 | 2.0418 | 104.477 | 2.0418 | 1 | 9.2262 | 12.0617 | 67.3602 | Exploitation |
| 31 | 0.4476 | 0.1549 | 1.3844 | 106.4639 | 1.2213 | 1 | 13.8397 | 57.7968 | 45.679 | Exploitation |
| 32 | 0.5003 | 0.4072 | 1.8999 | 131.8195 | 0.5 | 1 | 10.6036 | 41.5299 | 24.5124 | Exploitation |
| 33 | 0.5253 | 0.265 | 1.2009 | 108.9562 | 0.5 | 1 | 14.4637 | 73.3719 | 19.1489 | Exploitation |
| 34 | 0.4397 | 0.05 | 0.9508 | 115.4857 | 2.0418 | 17.7445 | 10.8301 | 96.3073 | 50.8989 | Exploitation |
| 35 | 0.4991 | 0.0526 | 0.9525 | 84.4283 | 2.0418 | 1 | 12.5072 | 42.8718 | 36.272 | Exploitation |
| 36 | 0.5408 | 0.2646 | 1.3466 | 138.6805 | 1.5344 | 3.6456 | 16.5801 | 73.7547 | 26.0069 | Exploitation |
| 37 | 0.4247 | 0.0796 | 0.7706 | 86.3453 | 1.3342 | 1 | 10.804 | 27.6396 | 51.2557 | Exploitation |
| 38 | 0.5187 | 0.3755 | 2.1987 | 95.0646 | 0.6121 | 1 | 13.4338 | 63.1148 | 22.8249 | Exploitation |
| 39 | 0.3798 | 0.1857 | 1.7591 | 138.7083 | 2.0418 | 1 | 15.3376 | 72.1757 | 61.4831 | Exploitation |
| 40 | 0.4616 | 0.05 | 2.0421 | 135.3405 | 2.0418 | 1 | 11.7925 | 35.9247 | 45.0918 | Exploitation |
| 41 | 0.5462 | 0.2159 | 1.076 | 118.5934 | 1.6814 | 1 | 16.4443 | 82.043 | 23.1233 | Exploitation |
| 42 | 0.5862 | 0.1895 | 0.5673 | 92.8326 | 1.2125 | 1 | 15.8289 | 76.0893 | 10.754 | Exploitation |
| 43 | 0.5152 | 0.2676 | 1.6247 | 124.7637 | 1.4928 | 1 | 16.4948 | 89.7484 | 30.5443 | Exploitation |
| 44 | 0.5624 | 0.3755 | 1.3996 | 99.9843 | 1.0018 | 1 | 16.5575 | 89.1708 | 15.746 | Exploitation |
| 45 | 0.4964 | 0.2933 | 1.388 | 97.4302 | 0.9302 | 1 | 16.4459 | 98.2523 | 32.4107 | Exploitation |
| 46 | 0.4913 | 0.1614 | 0.5 | 67.621 | 1.311 | 1 | 14.4817 | 63.4168 | 36.0949 | Exploitation |
| 47 | 0.5329 | 0.312 | 1.2314 | 98.9402 | 0.5105 | 1 | 13.6347 | 65.8273 | 17.3875 | Exploitation |
| 48 | 0.6052 | 0.3755 | 1.5278 | 99.9493 | 1.2642 | 1 | 16.5689 | 94.3435 | 4.7685 | Exploitation |
| 49 | 0.3643 | 0.05 | 0.5 | 72.2251 | 0.5 | 39.8397 | -10.4869 | 94.6586 | 62.0275 | Exploitation |
| 50 | 0.4756 | 0.05 | 0.5 | 87.1428 | 1.7145 | 8.7281 | 14.9761 | 99.2014 | 43.0201 | Exploitation |

### A.2 Implementation details of real-time experiment

For the real-time experiment implemented in the work, the performance function is chosen to be:

$$ $J=20\cdot(2.5-t_{s})-1.5\cdot O_{s}-4\cdot e_{ss},$ (17) $$

and the safety constraint functions are chosen to be:

$$ $G_{e}=100-40\cdot e_{ss},$ (18) $$

$$ $G_{u}=100-0.001\cdot\sum_{t=0}^{1}u(t)^{2},$ (19) $$

**Table 4: Intermediate experimental data in the real-time experiment using our method. $v_{p}$ and $v_{i}$ represent the proportional (P) and integral (I) gains of the speed controller, $d_{p}$ and $d_{i}$ represent the P and I gains of the $d$-axis current controller, and $q_{p}$ and $q_{i}$ represent the P and I gains of the $q$-axis current controller. "SS Error" represents steady-state error, and "Safety" represents control signal safety.**
| # | $v_{p}$ | $v_{i}$ | $d_{p}$ | $d_{i}$ | $q_{p}$ | $q_{i}$ | Performance | SS Error | Safety | Phase |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 0.1 | 0.1 | 0.5 | 100 | 0.5 | 100 | 11.0035 | 95.9985 | 95.4814 | Initial |
| 1 | 0.06 | 0.01 | 0.2309 | 80.5808 | 0.5444 | 90.3804 | -11.9492 | -0.0464 | 91.7061 | Exploration |
| 2 | 0.1417 | 0.1965 | 0.5398 | 80.7781 | 0.1659 | 113.6172 | 8.5604 | 99.3796 | 87.7946 | Exploration |
| 3 | 0.2237 | 0.1109 | 0.6148 | 123.2594 | 0.5974 | 52.1455 | 11.7734 | 95.9836 | 81.6459 | Exploration |
| 4 | 0.01 | 0.0924 | 0.6529 | 100.8284 | 0.5097 | 153.5284 | -19.9215 | 95.5276 | 96.6724 | Exploration |
| 5 | 0.2081 | 0.2389 | 0.3369 | 157.6717 | 0.5075 | 42.7193 | 11.1598 | 99.9918 | 80.9593 | Exploration |
| 6 | 0.142 | 0.2106 | 0.3848 | 8.8534 | 0.3728 | 46.6948 | 8.8304 | 97.5659 | 84.7725 | Exploration |
| 7 | 0.1223 | 0.01 | 0.3567 | 144.0673 | 0.273 | 67.1592 | 3.952 | 3.0145 | 88.4566 | Exploration |
| 8 | 0.2554 | 0.01 | 0.5631 | 200 | 0.5205 | 19.6379 | 13.354 | 44.3542 | 78.612 | Exploration |
| 9 | 0.3557 | 0.01 | 0.5301 | 200 | 0.202 | 1 | 10.8769 | 55.6689 | 61.1603 | Exploration |
| 10 | 0.2796 | 0.01 | 0.9273 | 200 | 0.559 | 1 | 7.2316 | 53.7155 | 61.1759 | Exploration |
| 11 | 0.5 | 0.01 | 0.4595 | 200 | 0.1 | 1 | 12.8577 | 66.5775 | 60.8505 | Exploration |
| 12 | 0.2184 | 0.4131 | 0.6188 | 114.6897 | 0.4886 | 75.4301 | 11.0777 | 96.3007 | 83.7109 | Exploration |
| 13 | 0.5 | 0.1603 | 0.6094 | 200 | 0.3745 | 20.8492 | 15.4139 | 89.5667 | 69.2582 | Exploration |
| 14 | 0.5 | 0.5 | 0.4882 | 200 | 0.4262 | 1 | 19.7221 | 98.8199 | 59.8462 | Exploration |
| 15 | 0.5 | 0.4787 | 0.708 | 200 | 0.1 | 59.7313 | -10.5227 | 8.5037 | 67.8852 | Exploration |
| 16 | 0.5 | 0.2079 | 0.2993 | 200 | 0.8111 | 1 | 22.4182 | 85.1099 | 60.729 | Exploitation |
| 17 | 0.5 | 0.01 | 0.1 | 200 | 1 | 1 | 21.9744 | 68.4442 | 64.8426 | Exploitation |
| 18 | 0.5 | 0.0784 | 0.5123 | 1 | 1 | 1 | 25.3585 | 94.8767 | 64.6963 | Exploitation |
| 19 | 0.5 | 0.5 | 0.1777 | 1 | 0.8568 | 1 | 24.9426 | 93.5693 | 61.5071 | Exploitation |
| 20 | 0.2687 | 0.5 | 0.3279 | 200 | 1 | 1 | 22.434 | 92.3163 | 68.8696 | Exploitation |
| 21 | 0.1125 | 0.5 | 0.61 | 1 | 1 | 1 | 21.3165 | 92.4869 | 70.7858 | Exploitation |
| 22 | 0.01 | 0.3793 | 0.1 | 200 | 1 | 1 | 2.6025 | 94.0543 | 75.0205 | Exploitation |
| 23 | 0.3562 | 0.5 | 1 | 101.1731 | 1 | 1 | 23.2112 | 86.8982 | 66.0899 | Exploitation |
| 24 | 0.5 | 0.3659 | 0.3963 | 1 | 1 | 200 | 11.4387 | 96.4774 | 73.9274 | Exploitation |
| 25 | 0.3148 | 0.5 | 1 | 1 | 0.3901 | 1 | 16.5616 | 99.5688 | 60.8859 | Exploitation |
| 26 | 0.2876 | 0.5 | 0.2985 | 60.4032 | 0.1 | 1 | 12.5954 | 97.3505 | 61.3896 | Exploitation |
| 27 | 0.5 | 0.01 | 1 | 1 | 0.6212 | 1 | 18.2358 | 70.9583 | 59.7129 | Exploitation |
| 28 | 0.445 | 0.1318 | 0.1 | 1 | 0.1 | 1 | 13.6719 | 87.6187 | 60.8697 | Exploitation |
| 29 | 0.294 | 0.23 | 1 | 200 | 1 | 1 | 17.9221 | 77.1942 | 66.8734 | Exploitation |
| 30 | 0.1634 | 0.01 | 1 | 1 | 1 | 1 | -1.4463 | 32.4374 | 71.1797 | Exploitation |
| 31 | 0.3797 | 0.01 | 0.1 | 73.7024 | 0.8042 | 1 | 14.3834 | 66.5341 | 60.5198 | Exploitation |
| 32 | 0.5 | 0.1739 | 1 | 99.2773 | 1 | 60.8785 | 14.1477 | 95.9631 | 75.2494 | Exploitation |
| 33 | 0.5 | 0.3595 | 0.6318 | 119.3289 | 0.7265 | 1 | 21.9547 | 80.9955 | 60.4072 | Exploitation |
| 34 | 0.1955 | 0.1931 | 1 | 65.5838 | 0.1 | 23.6959 | 5.7382 | 98.1549 | 78.003 | Exploitation |
| 35 | 0.0738 | 0.1239 | 1 | 102.2827 | 0.607 | 11.3087 | 28.5033 | 98.6823 | 78.0448 | Exploitation |
| 36 | 0.01 | 0.5 | 1 | 56.492 | 0.6984 | 1 | 1.6024 | 95.6198 | 73.2512 | Exploitation |
| 37 | 0.3586 | 0.4714 | 0.3571 | 22.3375 | 1 | 78.7476 | 15.8951 | 97.0151 | 77.549 | Exploitation |
| 38 | 0.0966 | 0.1369 | 0.4015 | 117.5416 | 1 | 8.5807 | 27.0349 | 98.0811 | 81.0718 | Exploitation |
| 39 | 0.3554 | 0.2399 | 0.6985 | 36.4461 | 0.6522 | 1 | 20.0828 | 78.7637 | 60.8838 | Exploitation |
| 40 | 0.1086 | 0.3105 | 0.8293 | 113.5326 | 1 | 14.2549 | 30.6683 | 99.9725 | 81.0333 | Exploitation |
| 41 | 0.5 | 0.5 | 0.1 | 128.9388 | 1 | 1 | 26.2538 | 92.9187 | 64.5912 | Exploitation |
| 42 | 0.5 | 0.01 | 0.7744 | 140.7811 | 1 | 1 | 22.6045 | 74.9451 | 65.0122 | Exploitation |
| 43 | 0.5 | 0.4052 | 0.5622 | 1 | 0.3601 | 1 | 22.1305 | 94.9982 | 63.7466 | Exploitation |
| 44 | 0.3633 | 0.2816 | 0.4332 | 100.1716 | 1 | 1 | 20.7604 | 80.434 | 69.1837 | Exploitation |

### A.3 Detailed proofs of theoretical results

#### A.3.1 Proof of Lemma 1

###### Proof.

For one-dimensional inputs $x_{i}$ and $y_{i}$, the Gaussian kernel is defined as:

$$ $K_{i}(x_{i},y_{i})=\exp\left(-\frac{\|x_{i}-y_{i}\|^{2}}{2\sigma_{i}^{2}} \right).$ $$

Each one-dimensional Gaussian kernel $K_{i}$ has a corresponding RKHS, denoted by $\mathcal{H}_{i}$, which satisfies the reproducing property.

Suppose there are $d$ one-dimensional Gaussian kernels, then the additive Gaussian kernel is constructed as:

$$ $K(x,y)=\sum_{i=1}^{d}K_{i}(x_{i},y_{i}),$ $$

where $x=(x_{1},x_{2},\ldots,x_{d})$ and $y=(y_{1},y_{2},\ldots,y_{d})$.

###### Proof.

##### Positive definiteness of the additive Gaussian kernel:

We first prove that $K(x,y)$ is a positive definite kernel. For any sample points $\{x_{1},x_{2},\ldots,x_{n}\}$ and corresponding non-zero weight vector $\alpha=(\alpha_{1},\alpha_{2},\ldots,\alpha_{n})$, $\alpha\in\mathbb{R}^{n}$, there is:

$$ $\sum_{j=1}^{n}\sum_{k=1}^{n}\alpha_{j}\alpha_{k}K(x_{j},x_{k})=\sum_{j=1}^{n} \sum_{k=1}^{n}\alpha_{j}\alpha_{k}\sum_{i=1}^{d}K_{i}((x_{j})_{i},(x_{k})_{i}).$ $$

Since each $K_{i}$ is positive definite,

$$ $\sum_{j=1}^{n}\sum_{k=1}^{n}\alpha_{j}\alpha_{k}K_{i}((x_{j})_{i},(x_{k})_{i}) \geq 0,$ $$

thus:

$$ $\sum_{j=1}^{n}\sum_{k=1}^{n}\alpha_{j}\alpha_{k}K(x_{j},x_{k})=\sum_{i=1}^{d} \sum_{j=1}^{n}\sum_{k=1}^{n}\alpha_{j}\alpha_{k}K_{i}((x_{j})_{i},(x_{k})_{i}) \geq 0,$ $$

which shows that $K(x,y)$ is a positive definite kernel.

##### Construction of the corresponding RKHS:

Now we prove that the RKHS corresponding to the additive Gaussian kernel can be constructed from the RKHSs of the individual one-dimensional Gaussian kernels.

Assume $\mathcal{H}_{i}$ is the RKHS corresponding to the kernel $K_{i}$. For any $f_{i}\in\mathcal{H}_{i}$, there exists a function $K_{i}(\cdot,x_{i})$ that satisfies the reproducing property:

$$ $f_{i}(x_{i})=\langle f_{i},K_{i}(\cdot,x_{i})\rangle_{\mathcal{H}_{i}}.$ $$

We construct the new function space $\mathcal{H}$ as the direct sum of these $\mathcal{H}_{i}$:

$$ $\mathcal{H}=\bigoplus_{i=1}^{d}\mathcal{H}_{i},$ $$

and in this new space, any function $f\in\mathcal{H}$ can be represented as:

$$ $f(x)=\sum_{i=1}^{d}f_{i}(x_{i}),$ $$

where $f_{i}\in\mathcal{H}_{i}$.

##### Inner product structure and completeness:

We define the new inner product in $\mathcal{H}$ as:

$$ $\langle f,g\rangle_{\mathcal{H}}=\sum_{i=1}^{d}\langle f_{i},g_{i}\rangle_{ \mathcal{H}_{i}}.$ $$

The completeness of $\mathcal{H}$ under this inner product is ensured because each $\mathcal{H}_{i}$ is complete, and the completeness of the direct sum space depends on the completeness of its component spaces.

##### Reproducing property:

Finally, we prove that the new RKHS $\mathcal{H}$ satisfies the reproducing property.

In each $\mathcal{H}_{i}$, the reproducing property is expressed as:

$$ $f_{i}(x_{i})=\langle f_{i},K_{i}(\cdot,x_{i})\rangle_{\mathcal{H}_{i}},$ $$

and we need to prove that for the new kernel function $K$, the reproducing property holds:

$$ $f(x)=\langle f,K(\cdot,x)\rangle_{\mathcal{H}}.$ $$

Note that the new kernel function $K$ can be expressed as:

$$ $K(x,y)=\sum_{i=1}^{d}K_{i}(x_{i},y_{i}),$ $$

therefore, for $f\in\mathcal{H}$ and any $x\in\mathcal{X}$,

$$ $f(x)=\sum_{i=1}^{d}f_{i}(x_{i})=\sum_{i=1}^{d}\langle f_{i},K_{i}(\cdot,x_{i}) \rangle_{\mathcal{H}_{i}}.$ $$

Using the definition of the new inner product,

$$ $f(x)=\sum_{i=1}^{d}\langle f_{i},K_{i}(\cdot,x_{i})\rangle_{\mathcal{H}_{i}}= \langle f,K(\cdot,x)\rangle_{\mathcal{H}},$ $$

which shows that the new kernel function $K$ satisfies the reproducing property in the new RKHS $\mathcal{H}$.

Therefore, the RKHS $\mathcal{H}$ corresponding to the additive Gaussian kernel $K$ is constructed from the direct sum of the RKHSs of the individual one-dimensional Gaussian kernels. The additive Gaussian kernel $K$ is a positive definite kernel and satisfies the reproducing property in its RKHS.
∎

#### A.3.2 Proof of Theorem 1

###### Proof.

Assume there are $d$ one-dimensional Gaussian kernels $K_{i}$, each corresponding to an RKHS $\mathcal{H}_{i}$. The additive Gaussian kernel $K$ is defined as:

$$ $K(x,y)=\sum_{i=1}^{d}K_{i}(x_{i},y_{i}),$ $$

where $x=(x_{1},x_{2},\ldots,x_{d})$ and $y=(y_{1},y_{2},\ldots,y_{d})$.

If a function $f$ has bounded norms in each of the RKHSs corresponding to the one-dimensional Gaussian kernels, there are:

$$ $\|f_{i}\|_{k_{i}}^{2}\leq B_{i},$ $$

where $\|f_{i}\|_{k_{i}}^{2}$ denotes the norm of $f$ in the RKHS $\mathcal{H}_{i}$ corresponding to each one-dimensional Gaussian kernel.

The RKHS $\mathcal{H}$ of the additive Gaussian kernel $K$ is the direct sum of the RKHSs $\mathcal{H}_{i}$:

$$ $\mathcal{H}=\bigoplus_{i=1}^{d}\mathcal{H}_{i}.$ $$

As defined in the proof of Lemma 1, in the RKHS $\mathcal{H}$, any function $f$ can be represented as:

$$ $f(x)=\sum_{i=1}^{d}f_{i}(x_{i}),$ $$

where $f_{i}\in\mathcal{H}_{i}$, then the norm of a function $f$ in the new RKHS $\mathcal{H}$ can be defined as:

$$ $\|f\|_{K}^{2}=\sum_{i=1}^{d}\|f_{i}\|_{k_{i}}^{2}.$ $$

Since the norm of $f$ in each one-dimensional RKHS $\mathcal{H}_{i}$ is bounded by $B_{i}$:

$$ $\|f_{i}\|_{k_{i}}^{2}\leq B_{i},$ $$

there is:

$$ $\|f\|_{K}^{2}=\sum_{i=1}^{d}\|f_{i}\|_{k_{i}}^{2}\leq\sum_{i=1}^{d}B_{i}.$ $$

Let $B=\sum_{i=1}^{d}B_{i}$, then:

$$ $\|f\|_{K}^{2}\leq B,$ $$

which shows that $f$ has a bounded norm in the RKHS associated with the additive Gaussian kernel $K$.
∎

###### Proof.

#### A.3.3 Proof of Theorem 2

###### Proof.

A Gaussian kernel is defined as:

$$ $K(x,y)=\exp\left(-\frac{\|x-y\|^{2}}{2\sigma^{2}}\right)$ $$

For the Lipschitz continuity of the Gaussian kernel, if we consider any two points $x$ and $y$ in the input space $\mathcal{X}$, we need to prove that there exists a constant $L$ such that:

$$ $|K(x,z)-K(y,z)|\leq L\|x-y\|$ $$

for all $z\in\mathcal{X}$.

Given that each one-dimensional Gaussian kernel $K_{i}(x_{i},y_{i})=\exp\left(-\frac{(x_{i}-y_{i})^{2}}{2\sigma_{i}^{2}}\right)$ is $L_{i}$-Lipschitz-continuous, then there exists a constant $L_{i}$ such that:

$$ $|K_{i}(x_{i},z_{i})-K_{i}(y_{i},z_{i})|\leq L_{i}|x_{i}-y_{i}|$ $$

for all $x_{i},y_{i},z_{i}\in\mathcal{X}_{i}$.

To prove that the additive Gaussian kernel $K(x,y)=\sum_{i=1}^{d}K_{i}(x_{i},y_{i})$ satisfies Lipschitz continuity, we need to show that there exists a constant $L$ such that:

$$ $|K(x,z)-K(y,z)|\leq L\|x-y\|$ $$

for all $x,y,z\in\mathcal{X}$.

Consider the difference of additive Gaussian kernels:

$$ $|K(x,z)-K(y,z)|=\left|\sum_{i=1}^{d}K_{i}(x_{i},z_{i})-\sum_{i=1}^{d}K_{i}(y_{ i},z_{i})\right|.$ $$

According to the triangle inequality,

$$ $\left|\sum_{i=1}^{d}K_{i}(x_{i},z_{i})-\sum_{i=1}^{d}K_{i}(y_{i},z_{i})\right| \leq\sum_{i=1}^{d}|K_{i}(x_{i},z_{i})-K_{i}(y_{i},z_{i})|.$ $$

Since each $K_{i}$ is $L_{i}$-Lipschitz-continuous,

$$ $|K_{i}(x_{i},z_{i})-K_{i}(y_{i},z_{i})|\leq L_{i}|x_{i}-y_{i}|,$ $$

thus:

$$ $|K(x,z)-K(y,z)|\leq\sum_{i=1}^{d}L_{i}|x_{i}-y_{i}|.$ $$

Let $\|x-y\|_{1}=\sum_{i=1}^{d}|x_{i}-y_{i}|$ represents the $\ell_{1}$ norm of the vector, there is:

$$ $\sum_{i=1}^{d}L_{i}|x_{i}-y_{i}|=\left(\sum_{i=1}^{d}L_{i}\right)\|x-y\|_{1}.$ $$

Note that there is the following relationship between the $\ell_{1}$ norm and the $\ell_{2}$ norm:

$$ $\|x-y\|_{1}\leq\sqrt{d}\|x-y\|,$ $$

thus:

$$ $\sum_{i=1}^{d}L_{i}|x_{i}-y_{i}|\leq\left(\sum_{i=1}^{d}L_{i}\right)\sqrt{d}\| x-y\|.$ $$

Let $L=\left(\sum_{i=1}^{d}L_{i}\right)\sqrt{d}$, then:

$$ $|K(x,z)-K(y,z)|\leq L\|x-y\|,$ $$

which shows that the additive Gaussian kernel $K$ satisfies $L$-Lipschitz continuity.
∎

###### Proof.

## Peer Reviews

confidence: 2
contribution: 3
initial_rating: 5
presentation: 3
questions: 1: Can you include an experiment with a truly high-dimensional system? 

2: As mentioned in the weakness section, I think cascade controllers are not a good example. I suggest something like distributed controllers in large water/power networks. Could you test the algorithms on more complex systems?
soundness: 3
strengths: - The paper addresses an important problem of (safe) BO, which is the limitation to low-dimensional problems. 
- Using additive kernel functions in a safe BO setting to increase its performance in high dimensional problems seems, to the best of my knowledge, a novel idea. The results indicate that this approach can be superior to "standard" safe BO approaches for some systems. 
- To the best of my knowledge, the math seems to be sound and the proofs are correct.
summary: In this paper, the authors propose a safe Bayesian optimization framework utilizing Gaussian processes with additive squared exponential functions. The motivation for the new kernel function is the poor performance of the "standard" SE kernel for high-dimensional spaces. The authors argue that using BO for controller tuning often requires operating in high-dimensional spaces due to a large number of parameters of the controllers to be considered. It is experimentally evaluated that the proposed algorithm, SafeCtrlBo, can lead to better results than other safe BO algorithms. Furthermore, the authors present theoretical results on the finite-time convergence of the algorithm.

The main contribution is utilizing additive SE-kernels in a Bayesian optimization framework and proofing the finite-time convergence.

UPDATE: score raised
weaknesses: 1. The main motivation for introducing the new kernel function is its superior in high dimensions. However, all evaluations in the paper are still pretty low-dimensional, with dimensions up to 10. In fact, in the related work it is mentioned that existing safe BO approaches work with systems where "three controller [...] each controller having only two parameters". However, the proposed algorithm is experimentally evaluated on the exact same numbers of parameters.

2. I agree that controller tuning including many parameters can be tricky. However, cascaded controllers are a bad example of that. In practice, these structures can be tuned very efficiently as you start with the inner loop until a specific performance is reached, then the next loop, and so on. All parameters are very meaningful, and the process is quite transparent. Furthermore, 
motor controllers are a bad example for safe BO. As long as no load is attached to the motor (something you don't do for tuning the controllers), it is almost impossible to destroy the system. Typical amplifiers do have a "max current" setting, or it is simply defined in the software. Therefore, I cannot understand the safety concerns that the authors mentioned for the experiment.

Long story short: Although the adapted safe BO method sounds interesting, the motivation with cascade controllers and the experimental evaluation are not a good choices.

---

confidence: 5
contribution: 2
initial_rating: 3
presentation: 3
questions: The statement "Srinivas et al. (2010) demonstrated that BO methods can converge to the global optimum of unknown performance functions in fewer steps compared to genetic algorithm." is incorrect. Nothing in the paper compares their approach to a genetic algorithm, and there is no discussion on this.

Similarly, the statement "However, SAFEOPT uses Gaussian kernels as the covariance function of the Gaussian processes, which is effective mainly for low-dimensional problems (Bengio et al., 2005)" is inaccurate. Berrkenkamp et al. (2016) use a Matern kernel and there is nothing in Sui et al. (2015) that indicates that a squared-exponential kernel is necessary.

Is equation (1) correct? Shouldn't the last term have t in the subscript instead of k? The same holds for equation 2.

I feel that theorems 4.1 and 4.2 are mostly trivial and should be placed in the appendix.

Does line 5 in the pseudocode simply mean that the algorithm picks the point with maximal variance in B_n? If so, why not just write sigma insteadl of un-ln?

The presentation of outermost evaluated safe points is somewhat confusing. Is a_{oes} in the dataset? Would it help to introduce the data set \mathcal{D}_n and to write a_{oes} \in \mathcal{D}_n?

Theorems 5.1 and 5.2 are unclear to me. What do the authors mean by the "maximum allowable uncertainty for the exploration to converge to an ( \epsilon )-reachable safe region." and "Maximum allowable uncertainty for the performance function to converge to a ( \zeta )-optimal function value."?

In the proof of Lemma C.1, the step from line 878 to 880 is incomplete. To show that the posterior variance is indeed increasing, the authors also need to show that [K_t^{-1} k_t(x)]_i is positive, which the authors do not do.

I might have missed something, but I am not sure if the statement in line 894 holds. Take, for example, the points x_sb =1, x_oes = 0 and x_i = 10. For \lambda=0, we have || x(\lambda) - x_i ||_2 = 10 > || x_sb - x_oes||_2 = 1, yet the inner product (x(\lambda) - x_i ) (x_sb-x_oes)  = (0-10 ) (1-0) <0 is negative.
soundness: 2
strengths: The paper is well-motivated and written in a very clear form. It also provides an adequate review of related works. The proposed algorithm is an interesting contribution and shows good empirical results.
summary: The authors propse a novel algorithm for safe Bayesian optimization that exploits purported properties of the squared-exponential kernel to facilitate the expansion of the safe set. The proposed idea is interesting and the authors report good theoretical results. However, the theoretical exposition is poor and the corresponding proofs are either incomplete or incorrect. Though I recommend rejection for this reason, I am open to changing my score if the authors improve the paper accordingly.
weaknesses: The theoretical results are mostly stated usinng plain text instead of mathematical formulas, which makes them somewhat ambiguous and hard to understand at times.

The proofs of the theoretical results are incomplete and potentially wrong.

---

confidence: 4
contribution: 2
initial_rating: 1
presentation: 2
questions: Please address the mentioned weaknesses. 

Additional questions on the hardware experiments: 
- When does the exploration phase stop, when does the exploitation phase start?
- How were the GP hyperparameters chosen? 
- Why and when do safety violations occur?
- How can $T_0$ be chosen in real-world applications?
soundness: 2
strengths: (S1) Clear motivation and objective 

(S2) Demonstration and benchmarking of  different safe BO algorithms on synthetic function and in a real-world use case. The application of multiple algorithms as baselines makes the results significant for the BO community. 

(S3) The provided implementation gives clear insights into the method and the experiments. 

In general, the contribution is reasonable. Focusing on the border of the safe set to reduce computational effort is a logical approach. Additive kernels seem to be able to enhance the performance of safe BO algorithms for high-dimensional systems. However, it remains unclear how to choose kernel hyperparameters in practice.
summary: The paper addresses safe Bayesian optimization (BO) to optimize the parameters of cascaded control systems. To make safe BO more suitable for this task, additive kernels are used as a model, and a new definition of expander sets is introduced, which makes the BO optimization more compute efficient. The method is benchmarked on synthetic functions and a hardware setup, tuning parameters for a field-oriented control algorithm in a permanent magnet synchronous motor. Although the proposed method outperforms other benchmarks, all tested safe BO methods result in safety constraint violations.
weaknesses: I see the following main weaknesses:

(W1) The embedding of related work is insufficient. There are lines of work, which seem closely related, but are not cited appropriately. 

(W2) Theoretical results are partially imprecise. Some of the results have been known before and build on previous results, yet these are not cited. 

(W3) In the empirical study, information is missing on how to apply the algorithm and how hyperparameters are chosen. The choice of heuristics is not sufficiently documented and discussed.

(W4) Safety violations in hardware experiments are not adequately discussed.

Below, I provide a more detailed discussion of these weaknesses, ordered by sections.


## Related work:

* In related work, Bottero et al. 2022 is missing. It would make sense to compare against this, as this work explicitly focuses on safe BO without expander sets. 
* Furthermore, studies on safe/constrained BO for cascaded control systems, such as Khosravi et al. 2022, seem directly related but are not mentioned. 


## Theoretical Results: 

* Lemma 4.1 is a known result that can be found in e.g., Berlinet and Agnan-Thomas 2004 Theorem 5
* Theorem 4.2 is imprecise; further information on this can be found in Fiedler 2023 (Section 4) 
* The theoretical results section clearly builds on Chowdhury and Gopalan 2017, Theorem 2, using their results for confidence bounds without referencing this paper.  
* There are more recent results on confidence bounds in GP Regression, which lead to more conservative bounds and do not rely on the information gain. Information on this can be found in Whitehouse et al. 2024
* Theorem 5.1: The RKHS norm of the safety functions is bounded by $B$ , not the safety functions themselves

## Empirical Study 

For the stage-wise approach it is unclear, when to go to the next stage. This can only be chosen through a heuristic. In the paper it remains unclear, how to choose this in a practical application. 

In the synthetic experiments, only a noise free setting is evaluated. The results would be more relevant and would underline the contribution of the method more, if function evaluations would be noisy. In addition, this setting would also better represent real-world settings. 

In the experimental evaluation, the choice of hyperparameters of the GP and the choice of $\beta$ is unclear. While in the theoretical derivations, the RKHS-norm bound and the information gain are used, in the experiments, $\beta = 2$ is used as a heuristic. This choice is common in other safe BO works; however, it is not made transparent in the paper and can only be found in the implementation. The use of this heuristic invalidates all proven safety guarantees. A detailed discussion on this can be found in Fiedler et al. 2024.

The choice and the long lengthscales in the kernel lead to safety violations. Typically, shorter lengthscales compared to the domain size are applied in safe BO applications. This limits performance while exploring but can lead to fewer safety violations. 
It would be interesting to know when safety violations occurred in the hardware experiments. I assume this is mostly in the first exploration stage.

For the hardware experiments, it is unclear what $T_0$ is and if there is even a switch in the exploitation stage. 

## Discussion

The safety violations that occur in the empirical results need to be more thoroughly discussed. In light of these, the claim in the conclusion that it "can be seamlessly integrated into real-world complex control applications." is too confident, having observed 39 safety violations in the hardware experiments. 


## Minor comments: 

Line 191 and 194: Definitions of safe set and expander sets in Sui 2015 and Sui 2018 are different
Line 206-207: This statement is wrong. Berkenkamp 2016 uses a Matern kernel; generally, in many SafeBO applications Matern kernels with $\nu = 3/2$ are used.
Line 333: Typo: Lipschitz continuous
Line 317-318: Grammar in Theorem 5.1 and Theorem 5.2 "with R-sub-Gaussian" 


## References (not in the paper)

- Berlinet, A., & Thomas-Agnan, C. (2004). _Reproducing Kernel Hilbert Spaces in Probability and Statistics_. Springer Science & Business Media.
- Bottero, A., et al. (2022). Information-theoretic safe exploration with Gaussian processes. _Advances in Neural Information Processing Systems_, 35, 30707-30719.
- Chowdhury, S. R., & Gopalan, A. (2017). On kernelized multi-armed bandits. In _International Conference on Machine Learning_ (PMLR).
- Fiedler, C. (2023). Lipschitz and Hölder continuity in reproducing kernel Hilbert spaces. _arXiv preprint arXiv:2310.18078_.
- Fiedler, C., Menn, J., Kreisköther, L., & Trimpe, S. (2024). On safety in safe Bayesian optimization. _Transactions on Machine Learning Research_.
- Khosravi, M., et al. (2022). Safety-aware cascade controller tuning using constrained Bayesian optimization. _IEEE Transactions on Industrial Electronics_, 70(2), 2128-2138.
- Whitehouse, J., Ramdas, A., & Wu, S. Z. (2024). On the sublinear regret of GP-UCB. _Advances in Neural Information Processing Systems_, 36.

---

confidence: 2
contribution: 4
initial_rating: 5
presentation: 4
questions: What are the consequences of violations of constraints in this test application? Do they make the algorithm unsafe for use in practice? Is there a parameter that can be changed to reduce the number of violations? Does that result in a trade-off between performance and number of constraint violations, and if yes, how can this trade-off be handled?
soundness: 4
strengths: The proposed method for using additive kernels in safety-aware BO leads to optimization in fewer trials, which is of great practical significance for physical control systems with safety limitations. The paper is written clearly, references prior work in the field, and explains very well the connections of the proposed method to that work. Although safe BO and additive functions are not novel ideas individually, their combination is original and based on significant technical insight. Properties of the proposed additive kernels are analyzed well theoretically. A novel acquisition function is proposed that is faster to compute than previously proposed ones. 

Furthermore, the method is tested on a physical control system set-up that is of real practical use. Because the optimized parameters of the controllers are their proportional and integral gains, the proposed method could potentially find widespread use in industrial practice, where the use of PI controllers is very common and their tuning is known to be notoriously tricky and laborious.
summary: The paper describes a method for safe Bayesian optimization suitable for control applications where safety concerns limit the set of parameters that can be tried. The main contribution is the use of additive kernels in safe BO, resulting in faster optimization. This contribution is of major significance when applying BO to physical systems, where control trials are slow and costly to perform. A second contribution is the speedup of the computation of the expander set, affecting the computational time of the algorithm. The proposed method has been verified on benchmark functions in simulation, as well as on a challenging control problem involving a physical set-up consisting of nested controllers regulating the velocity of a permanent magnet synchronous motor under field-oriented control.
weaknesses: The paper is somewhat incremental in the line of research on applying BO to safety-constrained control systems, and combines known ideas. Nevertheless, this combination required a significant technical insight, so it is far from obvious or trivial.

The experimental results on the physical system resulted in a significant number of constraint violations (39 for the method proposed by the authors). It is not clear what the consequences of these violations are in practice.

Meta-review: This paper investigate a SafeControlBO method to optimize multiple controllers at the same time. It shows improvements addressing the challenges associated with tuning complex control systems that involve multiple parameters while keeping online safety.
Strengths of the paper: effectively optimization while ensuring safety. Its empirical validation demonstrating superior performance compared to some existing safe Bayesian optimization methods. The use of additive kernels enhances efficiency, making it suitable for complex control systems. 
Weaknesses: incremental theoretical improvements, hyperparameter tuning issues.
The AC likes the paper in general, but the reviewers opinions make sense, this paper should be improved to reach the bar of ICLR.

Decision: Reject