Comparison of Deep Learning and Deterministic Algorithms for Control Modeling

Abstract

Controlling nonlinear dynamics arises in various engineering fields. We present efforts to model the forced van der Pol system control using physics-informed neural networks (PINN) compared to benchmark methods, including idealized nonlinear feedforward (FF) control, linearized feedback control (FB), and feedforward-plus-feedback combined (C). The aim is to implement circular trajectories in the state space of the van der Pol system. A designed benchmark problem is used for testing the behavioral differences of the disparate controllers and then investigating controlled schemes and systems of various extents of nonlinearities. All methods exhibit a short initialization accompanying arbitrary initialization points. The feedforward control successfully converges to the desired trajectory, and PINN executes good controls with higher stochasticity observed for higher-order terms based on the phase portraits. In contrast, linearized feedback control and combined feed-forward plus feedback failed. Varying trajectory amplitudes revealed that feed-forward, linearized feedback control, and combined feed-forward plus feedback control all fail for unity nonlinear damping gain. Traditional control methods display a robust fluctuation for higher-order terms. For some various nonlinearities, PINN failed to implement the desired trajectory instead of becoming “trapped” in the phase of small radius, yet idealized nonlinear feedforward successfully implemented controls. PINN generally exhibits lower relative errors for varying targeted trajectories. However, PINN also shows evidently higher computational burden compared with traditional control theory methods, with at least more than 30 times longer control time compared with benchmark idealized nonlinear feed-forward control. This manuscript proposes a comprehensive comparative study for future controller employment considering deterministic and machine learning approaches.

1. Introduction

As early as (at least) the late 19th century, scientists made efforts to design and implement control systems to deal with instability, oscillation, and various nonlinear and chaotic phenomena [1]. Maxwell studied valve flow governors [2], while more recently, Cartwright et al. used the van der Pol equation in seismology to model the two plates in a geological fault [3]. Fitzhugh [4,5] used the equation to model the action potentials of neurons. Systems exhibiting strong nonlinear behavior are tough problems to control. The standard practice of base controls on the linearization of the system is often rendered ineffective due to the elimination of the nonlinear features. Machine learning is one approach with seeming applicability due to its ability to learn and control nonlinear features.

1.1. Physics-Informed Machine Learning

There has been significant recent progress in the field of machine learning in recent decades, starting from the late 80s following the utter failure to achieve its “grandiose objectives” in the 1970s. Ref. [6] Taking advantage of “big data” and advanced computing technologies such as GPU and TPU computing, there has been exponential growth in the field of deep learning. Central Processing Units (CPU) manage all the functions of a computer and can be augmented by Graphical Processing Units (GPU) and Tensor Processing Units (TPU) to accelerate calculations with application-specific integrated circuits. In the past five years, an explosion of research has re-instantiated “grandiose objectives” manifest in “deep learning”. There have been attempts to insert physical information into neural networks (NN) since at least the 1990s, [7] relying both on statistical and symbolic learning, called hybrid learning [8,9,10,11]. Towell et al. [8] described hybrid learning methods using theoretical knowledge of a domain and a set of classified examples to develop a method for accurately classifying examples not seen during training. Towell et al. [9] introduced methods to refine approximately correct knowledge to be used to determine the structure of an artificial neural network and the weights on its links, thereby making the knowledge accessible for modification by neural learning. Towell et al. [10] illustrated a method to efficiently extract symbolic rules from trained neural networks.

Meanwhile, the recent development of physics-informed neural networks (PINNs), originally introduced in 2017 [12], encode differential equations in the losses of the NNs as a soft constraint enabled by automatic differentiation [13], allowing fast, efficient learning of physical mapping with relatively less labeled data. One well-known application is in the field of fluid fields [14,15]. An aspect not well known or studied is the implementation of control signals for nonlinear systems using PINNs enabled by inserting the control signals and positional constraints into the loss. This aspect is known as physics-informed deep operator control (PIDOC) [16]. Particularly, it is shown in this work that PIDOC can successfully implement controls to nonlinear van der Pol systems yet fails to converge to the desired trajectory when the system’s nonlinearity is large.

1.2. Deterministic Algorithms

In 2017, Cooper et al. [17] illustrated how an idealized nonlinear feedforward very effectively controlled highly nonlinear van der Pol systems with fixed parameters, while [16] adopting Cooper’s method as the benchmark for comparison, as done here in this manuscript. Based on the work presented in this manuscript on NN-based control and deterministic algorithms, it can be deduced that challenging problems remain open, particularly regarding controlling highly nonlinear systems. The ”grandiose objectives” referred to by Sir Lighthill [6] remain unfulfilled, and this insight guides both industry and academia efforts in controller design and system stability analysis.

There have also been attempts at comparing classical PID controllers with neural networks [18], refining PID controllers with neural networks [19,20], or inserting neural networks into traditional controllers in general [21,22,23]. Hagan and Demuth [21] provide a quick overview of neural networks and explains how they can be used in control systems. Nguyen et al. [22] demonstrated a neural network could learn of its own accord to control a nonlinear dynamic system, while Antsaklis [23] evaluated whether neural networks can be used to provide better control solutions to old problems or perhaps solutions to control problems that have proved to confound.

Inserting nonlinear approximation by neural networks to refine control and stability is not a new thing and is considered a type of “learning control” dating back to the 80s and 90s. Notwithstanding, as already introduced in [16], building control frameworks solely with neural networks is relatively rare. Acknowledging the deficiency of related works, this manuscript provides a fairly comprehensive analysis of PIDOC [16] as well as the original methods proposed by Cooper et al. [17] on the van der Pol system as a nonlinear representation of oscillating circuits, amongst other example applications. The key question we strive to answer in this paper is: What are the main differences between different methodologies in control modeling of nonlinear dynamics? To answer this, a benchmark is designed considering both the works and analysis of the systematic behavior. Afterward, desired trajectories were modified from the benchmark problem to check how the control methods differ by testing their first and second-order phase portraits.

In this manuscript’s Section 2 we briefly formulate the problem with a brief introduction to the van der Pol system and control schemes. In Section 3 we introduce the control approaches, including physics-informed deep operator control (Section 3.1), containing deep learning (Section 3.1.1) and physics-informed control (Section 3.1.2); and control theory algorithms in Section 3.2, with linearized feedback control (Section 3.2.1); idealized nonlinear feed-forward control (Section 3.2.2) and combined control (Section 3.2.3); we then briefly how the methods are compared in Section 3.3. Next Section 4 includes results comparing the control schemes: Section 4.1 shows how the methods differ on the benchmark problem; Section 4.2 shows how changing desired trajectories variate the controlled schemes; Section 4.3 shows how variegating systematic nonlinearity changes different control results.

2. Problem Formulation

As introduced in Section 1, the main goal is a comparison of control methods. The comparison studies are conducted on the van der Pol systems as prototype systems. A general system schematic of this paper is illustrated in Figure 1. The command signal was calculated by the controller, passing the control commands to the system, where the system’s nonlinear behavior is sensed and fed back using a sensor (not illustrated in the schematic). As the control loop stabilizes, the controlled dynamics are output for real-world applications. This manuscript mainly focuses on the controller (red box in Figure 1), PIDOC, and other control methods are all codified in the controller box.

The van der Pol system was adopted to test the control signals’ implementation, and a phase portrait of the van der Pol system is illustrated in Figure 2 where the system is arbitrarily initialized. Given arbitrary initial points, the trajectory always becomes “entrapped” in a nonlinear track (called a limit cycle), while control methods strive to release the trajectory from the trapped path along the limit cycle and drive the trajectory to some desired, commanded behavior. Such a system was first discovered by van der Pol when investigating oscillating circuits, taking the form [24,25]. van der Pol [24] introduced an oscillatory system with a damping that is negative. Together with van der Mark [25], he also illustrated how to design an electrical system such that alternating currents or potential differences will occur in the system, having a frequency that is a whole multiple of the forcing function.

$$\frac{d^{2}x}{d{t}^2}-\mu (1-x^2)\frac{dx}{dt}+x=0$$

(1)

where in the original circuits formulation, $x\left(t\right)$ is the current measured in amperes as the rate of change of the charge [26] and $\mu$ is a scalar parameter indicating the nonlinearity and the strength of the negative damping [16]. Henceforth, $x\left(t\right)$ is referred to as position.

For testing the proposed methods, control signals are formulated and passed forward to the nonlinear system as commands. The simulated system duplicated the system introduced in [16], where the MATLAB command odeint solves the equations providing data to feed the training of PIDOC. The van der Pol equation was solved in the time domain from time, $t=[0,50]$, and interpolated with 5000 points. The error control parameters rtol and atol are ${10}^{-6}$ and ${10}^{-10}$, respectively [28].

3. Methodology and Materials

This section briefly outlines the theoretical foundation of the physics-informed neural network-based algorithm and the alternative based on traditional control theory. The methodology of subsequent numerical experiments used for testing the methods is also introduced.

3.1. Physics-Informed Deep Operator Control

3.1.1. Deep Learning

Physics-informed deep operator control is enabled by the general deep neural network framework, where for the van der Pol system, the position is inferred based on the input time domain in accordance with Equation (2). Given an input time series t, the “predicted” trajectories out of the neural networks are $x_{pred}$. The process can be symbolized as

$$x_{pred}=(K_L\circ {\sigma }_L\circ \dots \circ K_1\circ {\sigma }_1\circ K_0)t$$

(2)

where $K_1,K_2,\dots ,K_L$, are linear layers; ${\sigma }_1,{\sigma }_2,\dots ,{\sigma }_L$ are the activation functions, where PIDOC employs tanh activation functions. More details of such methods can be found in Zhai and Sands [16].

A supervised machine learning framework is defined using external training data as a formulation minimizing the loss function so that the neural network can capture data features through an optimization process, whereas in traditional neural network approaches $\mathcal{L}$ is usually the difference (errors) between the neural network predictions and training data. Let $\mathcal{L}=\mathcal{L}(t,\mathbf{p})$ denote the loss function, where t is the input time series and $\mathbf{p}$ is the parameter vector contained in formations of $\mathcal{I}$, $\mathcal{D}$, and neural network. As no external constraints or bounds are enforced, the optimization problem hence takes the form of Equation (3) [16].

$$\underset{t\subset {\mathbb{R}}^{d_{out}}}{min}\mathcal{L}(t,\mathbf{p})$$

(3)

Minimizing $\mathcal{L}$ requires reiterating the neural network as defined for the “training”. The limited-memory Broyden–Fletcher–Goldfarb–Shanno optimization algorithm, a quasi-Newton method (L-BFGS-B in TensorFlow 1.x) [29,30] is adopted. Optimization is carried over iterations looping from the blue box (neural network) to purple box ($\mathcal{I}$ & $\mathcal{D}$) to red box ($\mathcal{L}$) displayed in Figure 3. The maximum iterations are set as $2\times {10}^5$. In the PIDOC formulation, $\mathcal{L}$ is calculated based on mean square errors of the encoded information to be construed in Section 3.1.2.

3.1.2. Physics-Informed Control

According to reference [16], the control function is enabled by encoding the control signal into the loss function of the neural network, inspired by the formulated physics-informed neural networks (PINNS) [12], where the loss function is computed through the mean squared errors (MSE) elaborated in Equation (4).

$$\mathcal{L}=MS{E}_{NN}+MS{E}_{\mathcal{I}}+MS{E}_{\mathcal{D}}$$

(4)

where $MS{E}_{NN}$, $MS{E}_{\mathcal{I}}$, $MS{E}_{\mathcal{D}}$ stands for the neural network generation errors, the initial position loss, and the control signal loss, respectively, computed as Equation (5).

$$\begin{array}{cc}\hfill MS{E}_{NN}& :=\frac{1}{N}\sum _{i=1}^N{\left[x_{train}-x_{pred}\right]}^2\hfill \\ \hfill MS{E}_{\mathcal{I}}& :=\frac{1}{N}\sum _{i=1}^N{\left[x_{pred}^0-x_{\mathcal{D}}^0\right]}^2\hfill \\ \hfill MS{E}_{\mathcal{D}}& :=\frac{1}{N}\sum _{i=1}^N{\left[\left(\frac{d{x}_{\mathcal{D}}^2}{d{t}^2}-\frac{d{x}_{pred}^2}{d{t}^2}\right)+\left(x_{\mathcal{D}}-x_{pred}\right)\right]}^2\hfill \end{array}$$

(5)

where $x_{\mathcal{D}}^0$ denotes the initial position of desired trajectory; $x_{pred}$ is the neural network predicted output; $x_{train}$ is the given training data (from system simulation); $x_{pred}^0$ and $x_{\mathcal{D}}^0$ denote the initial positions of the neural network predicted output and desired trajectory. Detailed formulations are elaborated by reference [16].

To impose the triangular function signals, we simply impose the form of $x_{\mathcal{D}}$ in Equation (6).

$$x_{\mathcal{D}}\left(t\right)=\mathrm{\Lambda }sin\left(t\right),⟹{\dot{x}}_{\mathcal{D}}\left(t\right)=\mathrm{\Lambda }cos\left(t\right),{\ddot{x}}_{\mathcal{D}}\left(t\right)=-\mathrm{\Lambda }sin\left(t\right)$$

(6)

Based on such an $x_{\mathcal{D}}$, the output phase portrait ($\dot{x}\left(t\right)$ versus $x\left(t\right)$ phase portrait) is expected to be a circular trajectory. To implement different amplitudes of the desired trajectory $\mathrm{\Lambda }$, we modify Equation (5) to encode the amplitude information into the neural network losses, given the same training data resulting in Equation (7).

$$MS{E}_{NN}:=\frac{1}{N}\sum _{i=1}^N{\left[x_{train}-\frac{x_{pred}}{\mathrm{\Lambda }}\right]}^2$$

(7)

where the above equations represent the general formulation of PIDOC. The detailed graphical representation is illustrated as in Figure 3B: the control system (deep blue box) first generates nonlinear data that feeds into the neural network, forwards the output to encode the control signals as shown in the deep red box into the loss function through automatic differentiation, and reiterates the training of the neural network until the control signal is fine-tuned for systematic output.

3.2. Deterministic Control Algorithms

For the alternative application of control theory, the general framework begins with the modification of Equation (8), where controller gains are calculated through the Ricatti equation becoming a controller known as the linear quadratic regulator (LQR) [17].

$$\frac{d^{2}x}{d{t}^2}-\mu (1-x^2)\frac{dx}{dt}+x=F\left(t\right)$$

(8)

where $F\left(t\right)$ is forced on the nonlinear systems to exert control. By modifying $F\left(t\right)$, different types of controls are implemented, where in our approach, we adopt nonlinear feed-forward ($\mathcal{FF}$), linearized feedback control ($\mathcal{FB}$), and the combined controls, to be elaborated in Section 3.2.1, Section 3.2.2 and Section 3.2.3, respectively.

3.2.1. Linearized Feedback Control

In control theory and sciences, a common first step in control design is linearizing nonlinear dynamic equations and then designing the control based on that linearization. For the van der Pol dynamics, Equation (8) can be linearized and reduced into Equation (9), expressed in state-variable formulation from which state space trajectories are displayed on phase portraits [17].

$$\frac{dx}{dt}=\mathbf{A}x+\mathbf{B}u$$

(9)

The infinite-horizon cost function given by Equation (10)

$$J={\int }_0^{t_{end}}[x^{\mathsf{T}}\mathbf{Q}x+u^{\mathsf{T}}\mathbf{R}u]dt,\mathbf{Q}={\mathbf{Q}}^{\mathsf{T}}⪰0,\mathbf{R}={\mathbf{R}}^{\mathsf{T}}\succ 0$$

(10)

The goal is to find the optimal cost-to-go function $J^{*}\left(x\right)$ which satisfies the Hamilton–Jacobi–Bellman Equation (11)

$$\begin{array}{c}\hfill \forall x,0=\underset{u}{min}\left[x^{\mathsf{T}}\mathbf{Q}x+u^{\mathsf{T}}\mathbf{R}u+\frac{\partial J^{*}}{\partial x}(\mathbf{A}x+\mathbf{B}u)\right]\end{array}$$

(11)

where to find solutions, Equation (12) is formed necessitating solution of (13) which is the algebraic Riccati equation. The solution of the equation is of well-known form. Note that the computation of $K_p$, $K_d$, and $\left[S\right]$ are based on Matlab®command [K,S,E] = lqr(A,B,Q,R)

$$J^{*}\left(x\right)=x^{\mathsf{T}}\mathbf{S}x,\mathbf{S}={\mathbf{S}}^{\mathsf{T}}⪰0$$

(12)

$$0=\mathbf{SA}+{\mathbf{A}}^{\mathsf{T}}\mathbf{S}-{\mathbf{SBR}}^{-1}{\mathbf{B}}^{\mathsf{T}}\mathbf{S}+\mathbf{Q}$$

(13)

where $\mathbf{A}$ and $\mathbf{B}$ are the expressions used in the linear-quadratic optimization leading to a feedback controller with linear-quadratic optimal proportional and derivative gains for $K_p$ and $K_d$. The closed loop dynamics are established by Equation (14) where the van der Pol forcing function $F\left(t\right)$ is a proportional-derivative (PD) controller whose gains used in this manuscript are from [17].

Adopting the linearized feedback control by Cooper et al. [17], Equation (8) can thence be expanded in the form:

$$\begin{array}{c}\hfill \frac{d^{2}x}{d{t}^2}-\mu (1-x^2)\frac{dx}{dt}+x\equiv F_{\mathcal{FB}}\left(t\right)=-K_d({\dot{x}}_d-\dot{x})-K_p(x_d-x)\end{array}$$

(14)

where $x_d$ is the desired trajectory; $K_d$ and $K_p$ are the derivative and proportional gain, respectively. Similar with our approach in Equation (6), $x_d$ is the desired control trajectory, writes $x_d=\mathrm{\Lambda }sin\left(t\right)$.

3.2.2. Nonlinear Feed-Forward Control

In idealized nonlinear feed-forward controls, the forced term $F\left(t\right)=F_{\mathcal{FF}}\left(t\right)$ having the form of the original van der Pol system with the desired trajectory $x=x_d$ executed on:

$$\begin{array}{c}\hfill \frac{d^{2}x}{d{t}^2}-\mu (1-x^2)\frac{dx}{dt}+x\equiv F_{\mathcal{FF}}\left(t\right)=\frac{d^2{x}_d}{d{t}^2}-\mu (1-x_d^2)\frac{d{x}_d}{dt}+x_d\end{array}$$

(15)

where $x_d$ is the desired signal, as in Equation (14). By implementing $x_d$ in the force term, the control is thence applied to the van der Pol system, defined as the nonlinear feed-forward control as the executed force term possesses the form of idealized nonlinear trajectory.

3.2.3. Combined Control

To apply both the idealized nonlinear feedforward trajectory combined with the linearized feedback, the force term of the combined control simply follows

$$F_{\mathcal{C}}\left(t\right)=F_{\mathcal{FF}}\left(t\right)+F_{\mathcal{FB}}\left(t\right)$$

(16)

where $F_{\mathcal{FB}}$ and $F_{\mathcal{FF}}$ are elaborated in Equations (13) and (14), respectively. $F_{\mathcal{C}}$ is then applied to the van der Pol system in following the same form as in Equations (13) and (14).

The basic framework of the controls is shown in Figure 3A: the signal command as shown in the deep red box ($x_d$ in our equations) is the first input to the automatic trajectory generator that is forwarded to the gains, and then forwarded to either feed-forward controls ($F_{\mathcal{FF}}$) on the lower light blue box or feedback controls ($F_{\mathcal{FB}}$) on the upper dark blue box or the combined approach. The control signals are tuned through the light blue tuner box on the right, which controls the force term applied to the nonlinear system as indicated in the solid blue box on the right. After exerting the desired control signals, the output signals are first fed to the gains as full state feedback indicated in the gray box; the final controlled dynamics are output after the workflow is executed iteratively.

3.3. Comparison and Estimation

To conduct a fair, decent, and comprehensive comparison of the proposed methods, we consider Systematic analysis of the provided benchmark problem as it has been mentioned in Section 1, Trajectory convergence for different amplitudes of desired trajectories, signified by $\mathrm{\Lambda }$ in Equation (6) and Non-linearity of the systems with different nonlinearities, signified through $\mu$ ion Equation (1). For the benchmark systematic behavior analysis, considering both the work of Zhai & Sands [16] and Cooper et al. [17], we pick $\mathrm{\Lambda }=5,\mu =1$, as a system with low nonlinearity; in which for the PIDOC framework, the NN has the structure of $6\times 30$. The initial point is picked as (1,0). For systems of different desired amplitudes, $\mathrm{\Lambda }$ is changed from $1,3,5,7,9$. For systems of different non-linearities, $\mu$ is changed from $1,3,5,7,9,10$. The PIDOC was conducted in Google Colab [31] using Python 3.6 compiling TensorFlow 1.x [30]. Both $\mathcal{FF}$, $\mathcal{FB}$ and $\mathcal{C}$ were written in Matlab R2021a and executed with Simulink.

4. Results and Discussion

4.1. Benchmark Analysis

The results of the benchmark analysis are shown in Figure 4, where Figure 4A,B stand for the first and second order phase portraits of different controlled schemes by PIDOC, $\mathcal{FF}$, $\mathcal{FB}$, & $\mathcal{C}$, marked in different colors dashed lines as elaborated in the caption; compared with the inherent van der Pol dynamics and desired trajectory marked in black and pink solid lines, respectively. The desired trajectories marked in pink are the same as previous works in the field [32,33,34]. The phase Figure 4C,D illustrated the time evolution of the zeroth, first, and second order derivatives of the position $x\left(t\right)$, with the same color representations as in Figure 4A,B. Given the benchmark problem, it can be deduced that all the control theory methods exhibit strong fluctuations at the initial stage of controls, where $\mathcal{FF}$ converge to the desired trajectory successfully, as indicated in the deep blue dashed lines, whereas both $\mathcal{FB}$ and $\mathcal{C}$ fails. Another interesting point to be noted is that all the traditional control algorithms exhibit a stronger fluctuation for higher order terms at the beginning stage, yet $\mathcal{FF}$ successfully converge to the trajectory that exhibits better control effects than PIDOC, but $\mathcal{FB}$ and $\mathcal{C}$ displays such a robust fluctuation along the time. To this phenomenon, we provide the following explanation: the errors generated by the linearization of the van der Pol equation accumulate and cause the robust fluctuations as indicated in Figure 4 for the light blue and red lines. However, admittedly, $\mathcal{FF}$ successfully implements the control with higher accuracy for higher order terms than PIDOC; but noted that as $\mathcal{FF}$ only forwarding control signals can be considered as an open-loop system, in real-world practice, trivial noises will be accumulated that leads to the in-feasibility of $\mathcal{FF}$.

4.2. Trajectory Amplitude

The results of controlled dynamics of trajectories of the first and second-order phase portraits are shown in Figure 5 and Figure 6, respectively. It can be discerned from Figure 5A,B that both PIDOC (symbolized as $\mathrm{\Pi }\mathcal{D}$ in the figure) and $\mathcal{FF}$ are able to implement controls with an exception of B1 that $\mathcal{FF}$ failed to control the system when $\mathrm{\Lambda }=1$. Similar to the benchmark problem that both $\mathcal{FB}$ and $\mathcal{C}$ failed to implement the controls with a highly fluctuating behavior, in Figure 5C,D. An interesting phenomenon reported from D1 to D5 is that with increasing trajectory amplitudes we report a better convergence for the combined ($\mathcal{C}$) control. We can hence propose the discussion on such phenomena that for higher values of desired trajectory amplitudes, the linearization effect of the feedback reduces for the van der Pol systems.

Figure 6 reports the second order phase portraits (acceleration-position diagram) comparing the four methods. Figure 6A reports the stochastic approximation nature of PIDOC: the learning-based control executes control signals based on randomized sampling for trajectory convergence. Corresponds to Figure 5B1 shows the failure of $\mathcal{FF}$ control when $\mathrm{\Lambda }=1$; whereas B2 to B5 shows how the second order phase portraits display a higher fluctuation, as also shown from in Figure 6C,D. Figure 6B also shows a strong discretized form of $\mathcal{FF}$ control, as illustrated based on the sparse points. The control contour from both Figure 5 and Figure 6 both $\mathcal{FB}$ and $\mathcal{C}$ controls (sub-figure C and D) shows an increased control density on the horizontal edges ($x\left(t\right)$ direction), indicated by the denser points.

The total computational burden of the four methods is shown in

Table 1. The computational burden of the four different control frameworks considering different desired trajectories (desired radius $\mathrm{\Lambda }$). Note that the unit are in seconds (default of timeit.time() in Python and cputime in Matlab).

$\mathbf{\Lambda }$	1	3	5	7	9
$\mathrm{\Pi }\mathcal{D}$	329.82	618.97	713.30	261.37	480.77
$\mathcal{FF}$	5.70	6.01	5.26	6.21	5.66
$\mathcal{FB}$	6.68	7.23	5.99	6.07	6.87
$\mathcal{C}$	8.35	6.63	7.62	6.46	6.06

: the PIDOC framework shows an evidently larger computing time than $\mathcal{FF}$, $\mathcal{FB}$ and $\mathcal{C}$; generally, $\mathcal{FF}$ execute the fastest control and $\mathcal{C}$ exhibits the longest control time within the tested control theory algorithms. We provide the following explanations for the above phenomena: (1) the PIDOC framework is based on the training of the NN, where the approximation of nonlinear data takes exponentially longer compared with just implementing the control commands; (2) since $\mathcal{FF}$ can be considered as an open-loop implementation of control signals, where the elimination of feedback and error adjustment reducing computation time; (3) the combination of both feed-forward and feedback requires estimation of the route execution and linearizations, consumes more time. Based on the computation time one can discern that although more stable control implementations are exhibited by PIDOC, the drawback is also evident: the considerably longer training time required for implementing the control.

4.3. Nonlinear Effects

The results of different control for systems of different nonlinearities with a fixed desired trajectory $\mathrm{\Lambda }=5$ are shown in Figure 7. Same as reported by Zhai & Sands [16], the PIDOC control fails to implement control for systems of high nonlinearities as to be “trapped” in a smaller radius trajectory. The $\mathcal{FF}$ control was implemented successfully, with a strong fluctuation reported for high nonlinearities observed from B1 to B5, with the failed implementation when $\mu =10$ as shown in B6, which can be considered as nonlinearity threshold. Both $\mathcal{FB}$ and $\mathcal{C}$ also failed for control execution same as in Figure 5 and Figure 6. To note, both the control theory methods implemented show an evident higher data density along the horizontal edges, which can be adopted to infer the nature of control theory methods: stronger control imposition near edges, corresponding to the wave crests and troughs as for the time evolution of the position.

The second order phase portraits are shown in Figure 8: as for the control theory methods, evidently higher nonlinearities are observed for $\mathcal{C}$ compared with $\mathcal{FF}$ and $\mathcal{FB}$; a more discrete points distribution indicates larger steps for control implementations. Just by observing Figure 8A, it is discerned that the systematic nonlinearity was very high, as indicated in the solid black line compared with the white dashed line for the desired trajectory. However, comparing B to D it is observed that for systems of higher nonlinearities, the control displays extremely strong fluctuations at the beginning stage of the control. Based on such a phenomenon, we hence deduce another finding for control theory properties: the control implementation will enlarge the nonlinear signals with larger steps of control discretization. To present a more detailed analysis of Figure 7 and Figure 8, Figure 9 is created for a zoomed view of the control schemes for both first and second-order phase portraits. Interestingly, vortex-liked structures are observed in the first-order phase portrait for both PIDOC and $\mathcal{C}$ along the edges of the circular trajectory. Figure 9B6 shows how $\mathcal{FF}$ fails control imposition in detail: an oscillation along the circular causes the “split” of the controlled trajectory vertically, where such a trend has already been observed in Figure 9B5. Figure 9C clarifies a phenomenon that has already been observed and discussed: an increased data density along the edges of the desired control schemes indicates a stronger control implementation along the edges.

The computational burden as shown in

Table 2. The computational burden of the four different control frameworks considering different systems of nonlinearities (different $\mu$ values). Note that the unit is in seconds (same as in Table 1).

$\mathit{\mu }$	1	3	5	7	9	10
$\mathrm{\Pi }\mathcal{D}$	713.30	257.64	305.91	225.15	197.76	199.52
$\mathcal{FF}$	5.26	10.33	7.77	6.45	5.38	5.12
$\mathcal{FB}$	5.99	5.61	6.84	6.02	5.52	5.30
$\mathcal{C}$	7.62	5.94	5.12	5.83	5.26	5.42

displays similar trends as in Table 1: PIDOC exhibits an evidently higher computation time attributed to the NN training. $\mathcal{C}$ exhibits a higher control time than $\mathcal{FF}$ and $\mathcal{FB}$. Another interesting phenomenon is: that with the increasing system nonlinearity, PIDOC shows a decreasing computation time. Corresponds to Figure 7, Figure 8 and Figure 9, we propose the following explanation: as the PIDOC-controlled schemes are entrapped in a trajectory with a lower radius, the NN straining stops at an earlier stage since the optimizer (L-BFGS-B) “discern” that more iterations won’t keep decreasing the loss, which leads to a lower computation time but lower quality control. To better quantify the computational burden differences,

Table 3. The relative computation time comparing PIDOC and control theory algorithms regarding different trajectories and nonlinearities.

$\widehat{\mathbf{𝓣}}$	$\mathbf{\Pi }\mathbf{𝓓}$	𝓕𝓕	𝓕𝓑	𝓒
$\mathrm{\Lambda }=1$	39.4999	1.0000	0.8000	0.6826
$\mathrm{\Lambda }=3$	93.3585	1.0000	1.0905	0.9065
$\mathrm{\Lambda }=5$	93.6090	1.0000	0.7861	0.6903
$\mathrm{\Lambda }=7$	40.4602	1.0000	0.9396	0.9613
$\mathrm{\Lambda }=9$	79.3355	1.0000	1.1337	0.9340
$\mu =1$	135.6084	1.0000	1.1388	1.4487
$\mu =3$	51.5006	1.0000	0.9444	1.7391
$\mu =5$	38.6258	1.0000	1.3359	1.5176
$\mu =7$	34.2228	1.0000	1.0326	1.1063
$\mu =9$	42.8036	1.0000	1.0494	1.0228
$\mu =10$	47.5353	1.0000	0.9779	0.9446

is created taking nonlinear feed-forward control employed by Cooper et al. [17] as a benchmark: PIDOC displays evidently higher computational burden compared with $\mathcal{FF}$, with at least more than 30 times of the benchmark time to up to 100 plus more times.

To quantify the control errors,

Table 4. The average absolute relative errors computed from the Equation (17) quantifying the control errors in correspondence with Figure 5 and Figure 7.

$\parallel \widehat{\mathbf{𝓔}}\parallel$	𝓒	𝓕𝓕	𝓕𝓑	$\mathbf{\Pi }\mathbf{𝓓}$
$\mathrm{\Lambda }=1$	2.1379	1.7199	2.0618	0.2225
$\mathrm{\Lambda }=3$	0.3645	0.4124	0.4473	0.2102
$\mathrm{\Lambda }=5$	0.3884	0.4245	0.6694	0.2128
$\mathrm{\Lambda }=7$	0.4168	0.4260	0.7288	0.3387
$\mathrm{\Lambda }=9$	0.4232	0.4264	0.7408	0.2788
$\mu =1$	0.3884	0.4245	0.6694	0.2056
$\mu =3$	0.8889	0.4306	0.6327	0.6590
$\mu =5$	0.8819	0.4353	0.6387	0.6074
$\mu =7$	0.8782	0.4425	0.6432	0.6345
$\mu =9$	0.8757	0.4443	0.6466	0.7101
$\mu =10$	0.8748	0.4847	0.6481	0.6690

is generated to compare the control qualities based on the absolute errors. The equation for computing the average absolute relative errors of different control signals are

$$\begin{array}{c}\hfill ∥\widehat{\mathcal{E}}∥=\sum _{i=1}^M\frac{1}{M}∥\frac{x_{control}-x_{\mathcal{D}}}{x_{\mathcal{D}}}∥\end{array}$$

(17)

It can be observed from Table 4 that PIDOC generally exhibits lower control errors compared with traditional control methods in different trajectories. For different nonlinearities, corresponding to Figure 9, it can be observed that nonlinear idealized feed-forward control exhibits better control qualities.

5. Conclusions

The nonlinear dynamics control modeling problems of the van der Pol system are tackled by comparing deep learning with traditional deterministic algorithms in this paper. The key idea of this work is to elaborate on the main differences by conducting a comprehensive comparison and benchmark for the recently proposed physics-informed neural networks control with other deterministic algorithms. We first design a benchmark problem for testing the system response for different methods. The desired trajectory and systematic nonlinearity are then changed to check the systematic responses of different controls. The computation burdens are also considered for different methods.

For benchmark analysis, results indicated that all the control theory algorithms exhibit a strong fluctuation which can be interpreted as enlarging the nonlinear inherent van der Pol dynamics with $\mathcal{FF}$ successfully implementing the controls, but the rest fails. The “nonlinearity enlargement” effect is observed to be more obvious for higher order terms. The PIDOC exhibits stochastic nature, which can be attributed to the nature of deep learning inference, same as reported by Zhai & Sands [16]. When changing the trajectory amplitudes, an interesting phenomenon is that $\mathcal{FF}$ failed for trajectory convergence when $\mathrm{\Lambda }=1$. Also, a higher control signal implementation density is observed along the horizontal edges of the first order phase portraits, unveiling control theory imposition to van der Pol systems executes stronger controls along the “signal waves’ crest and trough.” An evidently higher computation burden is observed for PIDOC in comparison to control theory methods. We explain such by the nature of NN learning: the recursive randomization of the NN weights and biases took a longer time than the direct execution of the control signal. For the van der Pol systems with different nonlinearities, it is observed that $\mathcal{FF}$ fails the control when $\mu =10$, whereas PIDOC also failed to implement controls when $\mu \ne 1$, as the controlled schemes were “trapped” into smaller trajectories. The “nonlinearity enlargement effect” for higher-order phase portraits for control theory algorithms. An interesting phenomenon of a vortex-liked structure of the controlled schemes, as originally reported by Zhai & Sands [16], has also been reported for the $\mathcal{C}$ controls. The evidently higher computation time is also reported for PIDOC, the same as what has been reported for different trajectories. For PIDOC, the computation burden generally reduces with systems of higher nonlinearities. The proposed comparison can guide the future implementation of deep learning-based controller designs and industrial selections.