{'fraction_non_alphanumeric': 0.042725622406639005, 'fraction_numerical': 0.010989367219917013, 'mean_word_length': 4.3734541020728095, 'pattern_counts': {'":': 0, '<': 6, '<?xml version=': 0, '>': 5, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 4, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Active Requirement Mining of Bounded-Time Temporal Properties of Cyber-Physical Systems

This paper uses active learning to solve the problem of mining bounded-time signal temporal requirements of cyber-physical systems or simply the requirement mining problem. By utilizing robustness degree, we formulates the requirement mining problem into two optimization problems, a parameter synthesis problem and a falsification problem. We then propose a new active learning algorithm called Gaussian Process Adaptive Confidence Bound (GP-ACB) to help solving the falsification problem. We show theoretically that the GP-ACB algorithm has a lower regret bound thus a larger convergence rate than some existing active learning algorithms, such as GP-UCB. We finally illustrate and apply our requirement mining algorithm on two case studies, the Ackley's function and a real world automatic transmission model. The case studies show that our mining algorithm with GP-ACB outperforms others, such as those based on Nelder-Mead, by an average of 30% to 40%. Our results demonstrate that there is a principled and efficient way of extracting requirements for complex cyber-physical systems.


Introduction
In this paper, we propose the use of active learning for mining bounded-time signal temporal logic (STL) requirements of cyber-physical systems (CPSs). CPSs are characterized by the tight interaction of a collection of digital computing devices (the Cyber part) and a continuous-time dynamical system (the Physical part) [3,22]. They are used for modeling in many safety-critical domains, such as automotive, medical, and aerospace industries, where the correctness of the end product is of significant importance [16,17,24]. However, in many industrial settings, the requirements intended to enforce the correctness guarantee are vague and in many cases expressed in natural languages, such as "smooth steering" and "good fuel efficiency." This prevents the application of formal verification tools, such as Statistical Model Checking (SMC) [31]. Further, due to the complex nature of many CPSs, writing down the appropriate requirements to reflect the desirable system properties can be challenging even for experienced designers.
Given a system S, e.g., a Stateflow/Simulink model of a steering system, and a requirement template ϕ with a set of unknown parameters θ , the goal of this paper is to develop an improved method which can automatically infer a requirement ϕ θ (often called a specification in formal methods literature) written in signal temporal logic, i.e., the system S satisfies the requirement ϕ θ . Such a problem can be called either a requirement mining problem or a temporal logic inference problem. In the past few years with the introduction of the concept of robustness degree [11,13], the problem has received increased attention and has achieved significant progress. Robustness degree quantifies how strongly a given sample trajectory s of a system S exhibits a temporal logic property ϕ θ as a real number rather than just providing a yes or no answer. A robustness degree of r(s, ϕ θ ) means that the trajectory s can tolerate perturbations up to the size of |r(s, ϕ θ )| and still maintain its current Boolean truth value with respect to ϕ θ .
With the help of robustness degree, the requirement mining problem of a CPS can be converted to an optimization problem for the expected robustness. Various techniques, such as particle swarm optimization [15], simulated annealing [21], and stochastic gradient descent algorithm [20] can then be used to solve the optimization problem 1 . Based on the nature of the search space, the requirement mining problems can be classified into two categories, parameter estimation problems and structural inference problems. In the former case, the structure of the requirement is given but with some unknown parameter values, for example, in a vehicular application, a requirement structure may be known as F [0,τ] (v > π), which means that "eventually between time 0 and some unspecified time τ, the speed v is greater than some unspecified value π." The goal of the parameter estimation problem is to identify appropriate values for the parameters [8,18]. In the latter example, even the structure of the requirement is unspecified. The structural inference problem is inherently hard. Candidate formulas have to be restricted to a certain template with which a partial order is well defined [19][20][21]. This paper focuses on the parameter estimation problem, but there are significant implications for structural inference as well.
Due to the hybrid nature of CPSs, the robustness degree function can be highly nonlinear. Furthermore, many CPSs are stochastic because of various uncertainties inherent to the system and its mathematical model. These complexities added together makes uniform sampling method inappropriate to solve the optimization problem (there are even cases in which the exact probability distribution over the parameter space is unknown a priori). Monte-Carlo techniques have been shown to be an effective sampling method to tackle the issue [2,18]. It is worth pointing out that these techniques may suffer from slow convergence, meaning that the inference procedure may take a long time. In many applications, a quick verdict is needed, consider for instance an online diagnosis of a faulty safety-critical system.
In this paper, we use active learning to partly mitigate the need for a large number of iterations during optimization. The idea behind active learning is to accelerate convergence by actively selecting potentially "informative" samples, in contrast with random sampling from a predefined distribution [25,28]. Active learning can be explained with a supervised video classification problem. With passive learning, a large amount of labeled data is needed for classification, e.g., cat videos vs. non cat videos.
Labeling itself involves an oracle, e.g., a human, and it might be time consuming. Further, much of the data may be redundant, not contributing much to the classification. With active learning, based on the current information gathered about the data distribution, the learning algorithm only asks for the label of the most informative data. In our setting, the CPS model together with a stochastic model checker will serve as an oracle, providing the learner an approximate expected robustness degree based on the current most informative parameter.

Contributions
The main contribution of this paper is an active learning based scheme for requirement mining of cyber-physical systems. It unifies two complementary camps of requirement mining and verification philosophies: one is model based [2,4,6,18,27], and the other is data driven [8,19,21]. In our method, models are used as oracles, generating data which enables our method to gain knowledge of the system. This helps focusing ongoing searches in promising parameter ranges, and thus eliminating unnecessary samples. The philosophy of our paper is similar to simulation based optimization [14] but with a particular focus on utilizing machine learning techniques. Second, instead of using existing learning algorithms, we develop a new active learning algorithm called Gaussian Process Adaptive Confidence Bound (GP-ACB). We prove that our GP-ACB algorithm converges faster than Gaussian Process Upper Confidence Bound (GP-UCP) algorithm [30], a state-of-the-art active learning algorithm. Third, we integrate our GP-ACB algorithm with an existing verification tool, called Breach [10].
Using an automatic transmission controller as an example system, we show that the efficiency of Breach can be improved by as much as 40%.
Organization This paper is subdivided into the following sections. Section 2 discusses the relevant background on signal temporal logic and Gaussian processes. Section 3 formally defines the requirement mining problem and shows how to transform the problem into an optimization problem with the help of robustness degree. Section 4 discusses our GP-ACB algorithm. Section 5 provides two case studies to demonstrate our algorithm, an academic example with Ackley's function as the target function and an automotive example. Section 6 concludes the paper. Signal temporal logic (STL) [23] is a temporal logic defined over signals. STL is a predicate logic with interval-based temporal semantics. The syntax of STL is defined as where a and b are non-negative finite real numbers, and f (s) ∼ d is a predicate where s is a signal, f ∈ F (R n , R) is a function, ∼∈ {<, ≥}, and d ∈ R is a constant. The Boolean operators ¬ and ∧ are negation ("not") and conjunction ("and"), respectively. The other Boolean operators are defined as usual. The temporal operators F and G stand for "Finally (eventually)" and "Globally (always)", respectively. The semantics of STL is recursively defined as In plain English, F [a,b) ϕ means "within a and b time units in the future, ϕ is true", and G [a,b) ϕ means "for all times between a and b time units in the future ϕ is true". STL is equipped with a robustness degree [11,13] (also called "degree of satisfaction") that quantifies how well a given signal s satisfies a given formula ϕ. The robustness is calculated recursively as follows We use r(s, ϕ) to denote r(s, ϕ, 0). If r(s, ϕ) is large and positive, then s would have to change by a large deviation in order to violate ϕ. Parametric signal temporal logic (PSTL) is an extension of STL where the bound d and the endpoints of the time intervals [a, b) are parameters instead of constants [6]. We denote them as scale parameters π = [π 1 , ..., π n π ] and time parameters τ = [τ 1 , ..., τ n τ ], respectively. A full parameterization is given as [π, τ]. The syntax and semantics of PSTL are the same as those of STL. A valuation θ is a mapping that assigns real values to the parameters appearing in an PSTL formula. A valuation θ of an PSTL formula ϕ induces an STL formula

Gaussian Processes
Formally, a Gaussian process (GP) is defined as a collection of random variables, any finite linear combination of which have a joint Gaussian distribution [26]. A simple example of a Gaussian process is a linear regression model , which maps an n-dimensional x to an N-dimensional feature space (a feature is an individual, measurable property of a function space), and w ∼ N ( 0, Σ), a zero mean Gaussian with covariance matrix Σ. Any GP is completely specified by its mean function m( x) and its covariance function or kernel k( x, x ) As an example, for the linear regression model, A flat (or even zero) mean function m( x) is chosen in the majority of cases in the literature. Such a choice does not cause many issues since the mean of the posterior process in not confined to zero. There is a large set of available kernels k( x, x ). Two common ones, which are also used in this paper, are [5] • Gaussian kernel with length-scale l > 0, k( x 1 , where K ν is the modified Bessel function and ν is a positive parameter.

Requirement Mining Problem Formulation
In this section, we first provide some background on our cyber-physical system models. We then formally define the requirement mining problem. Finally, we show how to formulate the requirement mining problem as an optimization problem.

Cyber-Physical Systems
In this paper, we study autonomous (closed-loop) cyber-physical systems. Notations from [2,27] are adopted here. A system S maps an initial condition (or uncontrolled environmental conditions, e.g., road conditions) with Y ⊂ R n y and T as the finite maximal simulation time.
We assume both X 0 and Y can be represented as the Cartesian product of intervals

Problem Statement
Formally, in this paper, we solve the following problem.
Problem 1. Given a system S with an initial condition set (or uncontrolled environmental condition set) X 0 ⊂ R n x and a parametric signal temporal logic formula ϕ θ with unknown parameters θ ∈ Θ ⊂ R n θ , where Θ is the set of feasible valuation, find a valuation θ such that That is to say, the output signal y of the system S, starting from any initial condition x 0 ∈ X 0 , satisfies ϕ θ at time 0. We write S( x 0 ) |= ϕ θ as shorthand for S( x 0 )[0] |= ϕ θ .

Requirement Mining as Optimization
Problem 1 is subject to the curse of dimensionality. If we solve Problem 1 directly, the dimension of the search space is n x + n θ . In this paper, we use the following three methods to mitigate the computational complexity.
• To reduce the search space's dimension, we follow the idea described in [18]. We divide Problem 1 into two sub-problems: a parameter synthesis problem (Problem 2) having a dimension of n θ and a falsification problem (Problem 3) having a dimension of n x .
• We then develop an active learning algorithm to progressively reduce the volume of the search space. The active learning algorithm focuses only on "informative" initial states, meaning it does not need to search the entire initial condition set X 0 .
• Finally, we take advantage of the monotonicity property of PSTL [18,20,21]. If a parameter has been found that solves Problem 2, then there is no need to check for parameters that make the requirement more restrictive, as these parameters surely do not constitute an optimal solution.
The flowchart to solve Problem 1 is shown in Fig. 1. Problem 2. Parameter Synthesis Given a system S with a set of inputsX 0 = { x i 0 ∈ X 0 , i = 1, 2, · · · , n s }, where n s is the number of counter-example traces obtained from Problem 3, and a PSTL formula ϕ θ with unknown parameters θ ∈ Θ ⊂ R n θ , find a valuation θ to solve max where ε > 0 us a user-specified bound.
Problem 3. Falsification Given a system S with an initial condition set (or uncontrolled environmental condition set) X 0 ⊂ R n x and a PSTL formula ϕ θ with particular parameters θ ∈ Θ, find an initial condition x 0 ∈ X 0 to solve The max function max(0, ε − ·) in Eqn. (3) is a modified hinge loss function. As the minimum of the robustness, min(r(S( x 0 ), ϕ θ )), is positive, the loss function rewards values that are close to the bound 0 and at the same time positive. It is utilized here to tackle the issue related to the non-uniqueness of solutions to the requirement mining problem, as pointed out in [18]. For a particular θ , the min functions in Eqn. (3) and Eqn. (4) reward initial states that lead to negative robustness degrees. Their goals are to find an initial state which leads to a trace that does not meet the requirement ϕ θ . The max-min function, Eqn. (3), then finds a parameter θ , and, in turn, a requirement ϕ θ such that for any initial state x 0 ∈ X 0 , the output of the system has a positive robustness degree that is smaller than ε. This means that the system satisfies the requirement ϕ θ , but only barely. Formally, Lemma 1. A formula obtained by solving Problem 2 and Problem 3 together is a solution to Problem 1. I.e., if a formula ϕ θ * , where and furthermore ∀ x 0 ∈ X 0 , r(S( x 0 ), ϕ θ * ) > 0, the statement (2) hold.
Proof. Assume there is a parameter θ obtained by solving Problem 2 and Problem 3, and x 0 ∈ X 0 : S( x 0 )[0] ϕ θ . According to Problem 3, a x 0 ∈ X 0 that meets the requirements cannot be found. Thus, Lemma 1 has been proven.
The most time-consuming part of solving Problem 1 is the generation of a trace given an initial state x 0 . For the parameter synthesis problem, there is no need to generate traces. Moreover, according to [18], since PSTL satisfies the important property of monotonicity, the solution is quite efficient, via a binary search algorithm [12], for example. The falsification problem, on the other hand, does need a large number of traces being generated. Therefore, finding a way to minimize the number of traces needed in the falsification step will benefit the requirement mining process greatly. In this paper, we solve the falsification problem with a new active learning algorithm called Gaussian Process Adaptive Confidence Bound (GP-ACB). We will show theoretically (in Section 4) and empirically (in Section 5) the effectiveness of our algorithm in reducing the computational time.

Active Learning Algorithm
In the section, we propose an active learning algorithm, called Gaussian Process Adaptive Confidence Bound (GP-ACB) algorithm, to solve the falsification problem mentioned in Section 3. It is inspired by Gaussian process upper confidence bound (GP-UCB) [30]. We analyze the regret bound of GP-ACB and show that it can achieve the same regret bound with a higher probability than GP-UCB.

Gaussian Process Adaptive Confidence Bound Active Learning Algorithm
Active learning algorithms are originally developed to solve classification problems when an oracle is needed to provide labels [28]. The process of obtaining labels from the oracle can be expensive in terms of both time and money. Thus, the goal of any active learning algorithm is to achieve high classification or regression accuracy by using the fewest labeled instances. The requirement mining problem suffers from a similar issue as elaborated at the end of Section 3. Our oracle is a simulator, e.g., a Stateflow/Simulink model. Given the complexity of many CPS models, to obtain a trace from the simulator can be costly in time. Thus, we need to decrease the number of simulations needed to learn a formula. One active learning algorithm is called Gaussian process upper confidence bound (GP-UCB) [30]. At each step t, it solves the following problem where D is the search space (D = X 0 for the requirement mining problem), β t is a function of t and independent of x (an example of β t will be given later), m t−1 (.) and σ t−1 (.) are the mean and covariance function of the Gaussian process, respectively, and x t is the instance that will be inquired at step t, meaning the label of x t will be obtained from the oracle. The GP-UCB algorithm balances the classical exploitationexploration trade-off by combining two strategies: the first term tends to pick those points that are expected to achieve high rewards (exploitation); and the second terms tend to pick those points that are uncertain (exploration). The second term of Eqn. (5) only depends on the covariance function σ ( x), which can potentially make the exploration somewhat random and inefficient. To address this problem, we propose an algorithm called Gaussian Process Adaptive Confidence Bound (GP-ACB) by adding a normalization term η m (x) to Eqn. (5) as follows: where η m ( x) normalizes the mean m t−1 ( x) and can be written explicitly as .
It is quite obvious that 0 ≤ η m ( x) ≤ 1. η m ( x) serves two main purpose here. First, it acts as an adaptive factor to uncertainty and favors exploration directions associated with increasing rewards. Thus, it can improve the exploration efficiency. Second, it provides an adaptive upper quantile of the marginal posterior P( f ( x) | y t−1 ), where y t−1 is a vector containing all the observations until time t − 1. In this paper, we assume that the observation at time t, y t ∈ R, is y t = f ( x) + ε t with ε t ∼ N (0, σ 2 ) and σ 2 known. Pseudocode for the GP-ACB algorithm is provided in Algorithm 1. Perform Bayesian update to obtain m t−1 ( x) and σ t−1 ( x);

Regret Bound of GP-ACB
The goal of any learning algorithm can be stated as follows: given an unknown reward function f ∈ F (D, R), maximize the sum of rewards ∑ T t=1 f ( x t ), which is equivalent to finding a x * such that x * = argmax x∈D f ( x). A concept called regret bound can be used to quantify the convergence rate of a learning algorithm [7,28,29]. First, the instantaneous regret at time t is defined as r t = f ( x * ) − f ( x t ). Then, the cumulative regret R T after T rounds is the sum of instantaneous regrets R T = ∑ T t=1 r t . A desired property of the learning algorithm is then to guarantee lim T →∞ R T /T = 0, implying the convergence to the global maximum x * . Finally, the bounds on the average regret R T /T are directly related to the convergence rate of the learning algorithm. The lower the bound is, the faster the algorithm converges. This section investigates the regret bound of the GP-ACB algorithm.
Our proofs on the regret bound follow those in [29]. Here we only consider the cases when the search space is finite, i.e., |D| < ∞.
Proof. According to the definition of x * , m t−1 ( . Therefore, the instantaneous regret , ∀ x ∈ D, and let β t be defined as in Lemma 4, then Remark 1. Lemma 5 shows that when the scale of the function L t is large, η m ( x) will be close to 1, meaning the GP-ACB algorithm degrades to GP-UCB. Conversely, when the scale of function is large, m t ( x) will play a more important role in the search process, driving the algorithm to be very greedy. To investigate the effects of the scaling function on the optimization performance, a numerical experiment has been conducted and the results are shown in Section 5.1.
Define γ T as the maximum information gain after T rounds as follows [29]: According to [29], if the search space D ∈ R d is compact and convex, where d is the dimension of the search space, with the assumption that the kernel function satisfies k( x, x ) 1, we have We can finally obtain the following bound for the GP-ACB algorithm.
Proof. Define the information gain I as follows: . . , f ( x T )) ∈ R T . According to Lemma 2 and Lemma 4, the regret bound According to Cauchy-Schwarz inequality, R 2 T ≤ T ∑ T t=1 r 2 t . Theorem 1 has been proven.

Remark 2. The regret bound of the GP-UCB algorithm is [29]
Pr{R With the same parameter setting, the regret bound of our GP-ACB algorithm is shown as Eqn. (7). Based on the bound of η( x) shown in Lemma 5 and the definition of the information gain γ T , we know that σ t−1 ( x t ) is close to 0 when T is large, which means m and n in Theorem 1 are close to one when iteration T is large and are close to zero when iteration T is small. This indicates that GP-ACB algorithm is greedy at the beginning and degrades to GP-UCB algorithm when iteration T is large. Since 0 < m, n 1, we can get the conclusion that the GP-ACB algorithm can get the same regret bound more efficient than that of the GP-UCB algorithm. The regret bound can be easily translated into convergence rate. The maximum max t≤T f ( x t ) in the first T iterations is no further from f ( x * ), where x * is the global optimum, than the average regret R T /T . Thus, compared with GP-UCB, on average, the GP-ACB algorithm has a higher or equal convergence rate.

Case Studies
To demonstrate the capability of GP-ACB, in this section, we first use it to solve a global optimization problem with Ackley's function as the target function. The performance of GP-ACP is compared with those of other active learning algorithms. We then use GP-ACB to solve a full scale requirement mining problem of an automatic transmission system, a benchmark used widely in CPS community [17,18,27]. In both cases, GP-ACB outperforms other active learning algorithms as well as some other state-of-art optimization algorithms such as Nelder-Mead.

Global Optimization of Ackley's Function
To verify the performance of the proposed GP-ACB algorithm, we compare the GP-ACB algorithm with four types of Gaussian-Process-based strategy: (i) GP-UCB active learning, (ii) Batch-greedy UCB active learning [9], (iii) pure exploration, i.e., choosing points of maximum variance at each step, and (iv) pure exploitation or greedy, i.e., choosing points of maximum mean at each step. We use Ackley's function (shown in Fig. 2.(a)) as the target function. Its formula is as follows, where e is the observation noise with zero mean and variance σ 2 at 0.025. The search space D = [−5, 5] 2 is randomly discretized into 1000 points. We run each algorithm for T = 58 iterations with sampling time δ = 0.1. Since the global minimum of the Ackley's function (x * , y * ) is known (unknown to the learning algorithms though), for the i-th trial, if (x i t , y i t ) is the solution obtained by running the algorithm for t iterations, then mean regret for the algorithm at time t isR t = ∑   Fig. 2(c) show the comparison of the mean regretR t incurred by the different Gaussian Process based algorithms with Gaussian kernel and Matérn kernel, respectively. With both kernels, GP-ACB outperforms the others. For instance, GP-UCB arrives at its minimum regret in an average of 58 iterations; while GP-ACB arrives at its minimum regret in an average of 45 iterations. Another interesting observation is that pure exploitation (greedy) strategy on average converges quicker than others. But the regret it converges to is on average higher than others, implying the convergence to local minimums. As for kernels, for this particular case, Matérn kernel outperforms the Gaussian kernel. This is not supervising, given that the Ackley's function (as shown in Fig. 2(a)) is quite "non-smooth" and Matérn kernel is designed to capture nonsmoothness.
Remark 1 shows that the range of the mean function m( x) at time t, affects the performance of the GP-ACB algorithm. When the range L t is large, the GP-ACB algorithm degrades to the GP-UCB algorithm. In this paper, we use a scale factor ξ to change the range of the reward or cost function. Instead of optimizing f ( x) directly, we scale it by ξ first and then solve the optimization problem with a new reward or cost function ξ f ( x). To demonstrate the effects, Fig. 3(a) shows the performance of GP-ACB with different scaling factors. It shows that when the scaling factor ξ is large, the algorithm prefers exploitation over exploration and has the danger of trapping in a local optimum; when the scaling factor ξ is small, the algorithm prefers exploration over exploitation and it may take more than necessary time to explore irrelevant regions. Thus, a proper ξ needs to be selected to balance the trade-off between exploration and exploitation. Fig. 3(b) shows the effects of the scaling factor ξ on different algorithms. It shows that when the scaling factor ξ is large, the GP-UCB and GP-ACB algorithms have the same mean regret after 58 iterations, implying GP-ACB has degraded to GP-UCB. The pure exploration and pure exploitation algorithms' performance are not effected by the scaling factor ξ .

Requirement Mining on an Automatic Transmission Model
The model used in the following study is the same as the one used in [18], a closed-loop model of a four-speed automatic transmission, shown in Fig 4. The model contains all necessary mechanical components, including engine, transmission and the longitudinal chassis dynamics. In the model, the throttle position and brake torque are the input signals. With the current gear selection, the transmission ratio (Ti) can be computed through the transmission block, and the output torque can be obtained with the engine speed (Ne), gear status and transmission RPM. We tested three different template requirements which are the same with [18], thus a comparison study can be conducted. The three template requirements are as follows: 1. Requirement ϕ sp rpm (π 1 , π 2 ), which has a strong correlation with safety requirements characterizing the operating region for the engine parameters speed and RPM, specifying that always the speed is below π 1 and RPM is below π 2 .
2. Requirement ϕ rpm100 (π, τ), which measures the performance of the closed loop system. The value for τ specifies how fast the vehicle can reach a certain speed, and the value for π can specify the lowest RPM needed to reach the above speed. The formula specifies that the vehicle cannot reach the speed of 100 mph in τ seconds with RPM always below π: ¬(F [0,τ] (speed > 100) ∧ G(RPM < π)).
3. Requirement ϕ stay (τ), which encodes undesirable transient shifting of gears, specifying that whenever the system shifts to gear 2, it dwells in gear 2 for at least τ seconds: Our requirement mining algorithm as shown in Fig. 1 and elaborated in Section 3.3 is implemented to mind requirements for the automatic transmission model. Our algorithm is based on the Breach toolbox [10] with the falsification problem solved by GP-ACB. The Breach toolbox uses the Nelder-Mead algorithm for falsification [10,18]. Section 5.1 shows that the scaling factor affects the performance of the GP-ACB algorithm. We first run a few test trials in order to find the optimal scaling factor, the results of which are shown in Table 1. It can be seen that when scaling factor is set to 0.5, the time spent on falsification, the time spent on parameter synthesis and the number of simulations are all at their lowest values. Thus, the scaling factors are set to 0.5 for all the following experiments.  In this  table and Table 2, "Parameter Values" are the mined parameter values. For instance, parameter values (4849, 155) together with the formula template ϕ sp rpm (π 1 , π 2 ) means that the mined formula is G((speed < 4849) ∧ (RPM < 155)). "Fals.(s)" is the CPU time spent on solving the falsification problem. "Synth.(s)" is the CPU time spent on solving the parameter synthesis problem. "#Sim." is the number of simulations."Robustness" is the robustness degree corresponding to the mined parameters.
Scaling The comparison results, averaged over 20 randomly started trails, for GP-ACB with Gaussian kernel, GP-ACB with Matérn kernel, GP-UCB and Nelder-Mead are shwon in Table 2. The results show GP-ACB with Matérn kernel outperforms the others in terms of the times spent on falsification, the times spent on parameter synthesis and the numbers of simulations. For instance, in mining the formula ϕ sp rpm (π 1 , π 2 ), GP-UCB saves on average 10% of simulation number compared with Nelder-Mead, while GP-ACB with Matérn kernel saves up to about 40%. The same level of improvement is observed for the other two requirements, ϕ rpm100 (π, τ) with a 40% improvement and ϕ stay (π) with a 30% improvement.

Conclusions and Future Work
In this paper, we introduced an active learning method, called Gaussian Process adaptive confidence bound (GP-ACB), for mining requirements of bounded-time temporal properties of cyber-physical systems. The theoretical analysis of the proposed algorithm showed that it had a lower regret bound thus a higher convergence rate than other Gaussian-Process-based active learning algorithms, such as GP-UCB. By using two case studies, one of which was an automatic transmission model, we showed that our requirement mining algorithm outperformed other existing algorithms, e.g., those based on GP-UCB or Nelder-Mead, by an average of 30% to 40%. Our results have significant implications for not only the requirement mining but also the validation and verification of cyber-physical systems. We are currently exploring the possibility of utilizing active learning to solve the structural inference problem, i.e., to mind a requirement without any given template.