A method for constructing a deep neural operator controller with a reflux device reactor
By constructing a time-delay compensation controller based on a deep operator network, the problem of long calculation time of the time-delay compensation controller in the plug flow tubular reactor is solved, and fast response and efficient system control are achieved.
Patent Information
- Application Number
- CN202510114536.4
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Filing Date
- 2025-01-24
- Publication Date
- 2025-10-17
- Estimated Expiration
- 2045-01-24
AI Technical Summary
The existing time-delay compensation controller has too long calculation time and insufficient robustness in dealing with non-constant time-delay plug flow tubular reactors, making it difficult to meet the requirements of fast response and system stability.
A time-delay compensation controller based on a deep operator network is constructed. By building a system model of the time-delay compensation controller and using Chebyshev polynomials to generate a training data set, the deep operator network is trained to directly learn the nonlinear mapping between the time-delay function and the system state, thus simplifying the controller solution process.
The solution speed and robustness of the controller are significantly improved, and it can quickly respond to system changes while ensuring accuracy, reducing calculation time. It is suitable for complex dynamic systems with time-delay changes.
Smart Images
Figure CN119960308B_ABST
Abstract
Description
TECHNICAL FIELD
[0001] The present application relates to the technical field of nonlinear system control, in particular to a deep neural operator controller construction method for a reactor with a reflux device. BACKGROUND
[0002] In chemical engineering, plug-flow tubular reactors are usually equipped with a reflux device to improve reaction efficiency, conversion rate and temperature control. The steam temperature in the reactor varies with position and time, and the reflux system adjusts the temperature by re-introducing part of the steam into the reactor to meet the expected process requirements. The inflow of the reactor is given by the controller, which is generally robust, but despite the micro hysteresis, it still poses a challenge to the response speed of the system, and even leads to system instability, so it is necessary to compensate for the time delay caused by the transmission effect. The current time delay compensation controller is mainly obtained by tedious calculation through numerical solution method, and the calculation time of this method will increase exponentially with the increase of spatial sampling accuracy, especially for the case of non-constant system time delay, additional calculation is needed to compensate for the time delay in the controller.
[0003] Neural networks are often used to directly approximate a certain class of functions from inputs and outputs, while the latest deep operator network (DeepONet) can learn the mapping between infinite-dimensional functions based on the former, with stronger self-learning ability, non-linear mapping ability and modeling ability for complex dynamic systems. Currently, the use of deep operator networks to solve the control problem of nonlinear systems mainly focuses on dealing with non-time delay or constant time delay, and the learning goal is the backstepping method kernel function, which is then used to calculate the controller gain by numerical solution method, which is an indirect method to improve the solution efficiency, but in the case of time delay size varying with space, the selection of controller branch, interpolation and iterative operation still requires a lot of calculation time. SUMMARY
[0004] The purpose of the present application is to provide a deep neural operator controller construction method for a reactor with a reflux device, which can improve the solution speed of the controller.
[0005] To achieve the above purpose, the present application provides the following scheme:
[0006] A deep neural operator controller construction method for a reactor with a reflux device, comprising:
[0007] Based on the plug-flow tubular reactor system model with reflux function, a time delay compensation controller system model is constructed;
[0008] determining a time delay function according to the time delay compensation controller system model, taking the time delay function as an input of a deep operator network, and constructing a deep operator network of nonlinear mapping;
[0009] generating an initial state of a dynamic response based on Chebyshev polynomials, extracting a state function of an input from the dynamic response, and determining a training data set based on the state function;
[0010] training the deep operator network by using the training data set, verifying that the deep operator network can stabilize a class of distributed parameter systems described by partial differential equations (PDEs) with spatially varying time delays by using a test set, and completing construction of a deep neural operator controller.
[0011] Optionally, the function representation of the plug flow reactor system model with reflux function is specifically:
[0012]
[0013] x(0,t) = U(t),
[0014] x(s,0) = x0(s),
[0015]
[0016] wherein, is a dimensionless position, and needs to satisfy 0≤s≤q≤1; the state x(s,t) is a steam temperature at a position s inside the reactor at a time t; the time delay function and: definition
[0017]
[0018] wherein represents a maximum value of the time delay function, τ' represents a derivative of the time delay function with respect to space; f(s,q)∈C 1 [0,1] is defined as a heat transfer coefficient inside the reactor, c(s)∈C 1 [0,1] represents a temperature decay coefficient, and c(1) = 0; the boundary controller U(t) is applied at the position x(0,t) for compensating the spatially varying time delay; x(0,t) represents an entrance of the reactor; x(1,t-τ(s)) represents a temperature of the reflux steam; x0(s) represents a temperature distribution at t = 0; x(s,h) = 0 represents that the reactor temperature is zero before t < 0, an initial time.
[0019] Optionally, the construction process of the time delay compensation controller system model comprises:
[0020] Based on the classical idea of handling the delay, a two-dimensional transmission PDE is first introduced to hide the time delay in the state variable, and the following equation is obtained:
[0021]
[0022] x(0,t)=U(t),
[0023]
[0024] u(s,1,t)=x(1,t),
[0025] x(s,0)=x0(s),
[0026]
[0027] where u(s,r)∈L2([0,1] 2 ) represents the time-delay state variable, and the system is constructed with the state variable u, and the solution of which satisfies the following equation:
[0028]
[0029] The newly introduced state u(s,r,t) can decouple the time delay in the x(1,t-τ(s)) term, and since this level system is equivalent to the original target system, the equivalent time delay compensation controller system model is directly designed for the original system of the plug flow reactor system model with backflow function based on the PDE;
[0030] Based on the backstepping method, the state feedback for the time-delay system is designed, and the affine Volterra integral transformation is introduced:
[0031]
[0032] where z(s,t) is the state variable of the stable target system; x(s,t) and u(s,r,t) are the state variables of the original system; K(s,q) is the kernel function system of the backstepping method; c(q) represents the temperature decay coefficient in the reactor; τ(q) represents the time delay function varying with space; δ(q) represents the impulse function; and the following stable target system is obtained through the transformation:
[0033]
[0034] z(0,t)=0,
[0035]
[0036] u(s,1,t)=z(1,t)
[0037] Therefore, the kernel function should satisfy the following equation relationship:
[0038]
[0039] The boundary conditions are determined according to the spatial position:
[0040]
[0041] where g(q):=q-τ(q), the maximum value on the region q∈[0,1] is defined as In order to ensure the existence of its inverse function, it is assumed that for So that when q>τ(q), the derivative of the delay function τ'(q)<1.
[0042] At the same time, the controller will produce the following two branches according to the amplitude of the delay:
[0043]
[0044] where the function set
[0045] Optionally, the structure of the depth operator network specifically comprises:
[0046] a branch network and a trunk network connected in sequence;
[0047] The branch network contains 3 convolutional layers, each using a convolutional filter with a kernel size of 5 and a step size of 2; the branch network further includes two fully connected layers with sizes of 1152x512 and 512x256, respectively; since τ(s), x(s) and u(s,r) have different input dimensions as the branch network, τ(s) and x(s) need to be expanded to 2 dimensions along the r-axis, and the expanded τ(s) and x(s) are stacked with u(s,r) sampled on a 21x21 grid to obtain a 3x21x21 tensor as the input of the neural operator network; the trunk network is used to encode the input function in discrete space, i.e., sampling on a grid (s,r)∈[0,1] 2 with a spatial step size of 0.05 to convert the spatial variable into a high-dimensional feature representation;
[0048] The width of the last hidden layer of the branch network and the trunk network is 256, so the outputs of the two sub-networks are combined into a new vector, and then the intermediate vector is output through multiple fully connected layers to obtain a scalar with a size of 1.
[0049] Optionally, the determination method of the training data set is:
[0050] According to the two branch expressions generated by the controller, the input of the neural operator for training the approximate target needs to include: time delay τ(s), state x(s) and time-delayed state u(s,r); the input of the neural network determines the upper limit of the output accuracy, so for The time-delay function of the controller is taken from a class of Chebyshev polynomials, namely in Γ1~U[0,8]; the function family shows significant parameter sensitivity, and the oscillation frequency of the polynomial is controlled by Γ1. By using Chebyshev polynomials to generate data, it is ensured that the generated data covers various behavior modes of the target function; for In order to satisfy the assumption, we define the family of functions in And Γ2~U[0.8,2.4]; However, for the input state variables x(s) and u(s,r), the two show correlation, that is, the state u is actually the past version of x. In order to avoid searching for the nonlinear mapping between the input function and the controller in an overly large function space and reduce the size of the data set, the two state variables x(s,t i ), u(s,r,t i ), where i = 1, 2, 3, ..., specifically, for any set (x0, τ) randomly generated by the Chebyshev polynomial, a dynamic response trajectory about the state x is generated by the controller, and the trajectory of t∈[0,12] is taken out of two states at different times according to the time step Δt, and a set of inputs (τ, x, u) is formed in combination with the time lag function to obtain the training data set.
[0051] Optionally, in the process of training the deep operator network using the training data set, after 250 epochs, the test error is 5.89E-4.
[0052] Optionally, in the process of training the deep operator network using the training data set, a smooth L1 norm is used as a loss function.
[0053] According to the specific embodiments provided by the present invention, the present invention discloses the following technical effects:
[0054] The application discloses a deep neural operator controller construction method with a backflow device reactor, and the method comprises the following steps: constructing a time delay compensation controller system model based on a plug flow reactor system model with a backflow function; determining a time delay function according to the time delay compensation controller system model, taking the time delay function as an input of a deep operator network, and constructing a deep operator network of a nonlinear mapping; generating an initial state of a dynamic response based on a Chebyshev polynomial, extracting a state function of the input from the dynamic response, and determining a training data set based on the state function; and training the deep operator network by using the training data set. The application can improve the solving speed of the controller while ensuring the control precision through a test set verification. BRIEF DESCRIPTION OF DRAWINGS
[0055] In order to more clearly illustrate the technical solutions in the embodiments of the present application or the prior art, the drawings needed in the embodiments will be briefly introduced as follows. Obviously, the drawings in the following description only represent some embodiments of the present application, and other drawings can be obtained by those skilled in the art without any creative effort.
[0056] Figure 1 It is a control schematic diagram of the plug flow reactor in the embodiment;
[0057] Figure 2 It is a flow chart of the numerical solution controller and the deep neural operator controller in the embodiment;
[0058] Figure 3 It is a deep operator network structure schematic diagram for implementing the neural operator in the embodiment;
[0059] Figure 4 It is the approximate effect and noise resistance capability when the neural operator controller is applied in the embodiment;
[0060] Figure 5 It is a flow schematic diagram of the deep neural operator controller construction method in the embodiment. DETAILED DESCRIPTION
[0061] The technical solutions in the embodiments of the present application will be described clearly and completely below with reference to the drawings in the embodiments of the present application. Obviously, the described embodiments only represent some embodiments of the present application, rather than all the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those skilled in the art without any creative effort fall within the protection scope of the present application.
[0062] The purpose of the present application is to provide a deep neural operator controller construction method with a backflow device reactor, which can improve the solving speed of the controller.
[0063] In order to make the above objectives, characteristics and advantages of the present application more obvious and easy to understand, the present application will be further described in detail below with reference to the drawings and specific embodiments.
[0064] As shown in Figures 1-5 , the present application provides a deep neural operator controller construction method with a backflow device reactor, comprising:
[0065] Step 100: based on the plug flow reactor system model with backflow function, a time delay compensation controller system model is constructed.
[0066] Step 200: according to the time delay compensation controller system model, a time delay function is determined, the time delay function is taken as the input of the deep operator network, and a deep operator network with nonlinear mapping is constructed.
[0067] Step 300: based on Chebyshev polynomials, an initial state of dynamic response is generated, a state function of input is extracted from the dynamic response, and a training data set is determined based on the state function.
[0068] Step 400: the deep operator network is trained using the training data set, and the neural operator controller obtained by training is evaluated through a test set, and the network meeting the stability requirement is determined as the deep neural operator controller.
[0069] Based on the above technical solution, an embodiment as shown in Figures 2-4 is provided.
[0070] As a specific application process of the plug flow reactor, as shown in Figure 1 , the reactants flow into the reactor from the left side, the flow rate is given by the controller U(t), the jacket around the reactor is used to control the temperature inside the reactor, and the heating or cooling of the steam during the reaction is adjusted; the state x(s,t) represents the steam temperature at position s inside the reactor at time t, which is a time variable, and its state changes with the length of the pipe and the change of time, x(0,t) and x(1,t) are the steam temperatures at the inlet and outlet of the reactor respectively, s∈[0,1] is a dimensionless position; at the same time, part of the steam will re-enter the reactor through the backflow pipe. This backflow mechanism helps to control the temperature uniformity in the reactor and optimize heat transfer. The temperature of the backflow steam is represented as x(1,t-τ(s)), where τ(s) is the delay time caused by the transmission distance, which depends on the pipe length and flow rate.
[0071] The embodiment aims to provide a neural operator control method for stabilizing a target partial differential system with a spatially varying time delay, which takes the variable time delay function and system state as the input of the neural operator network, directly trains the controller of the system through the deep operator network, avoids the selection of controller branches and various cumbersome numerical calculations, and greatly speeds up the solving speed of the controller.
[0072] As a specific embodiment, the deep neural operator controller with a reflux device reactor provided by the embodiment includes mechanism modeling of a variable time delay system, design of an analytical controller, construction of a deep operator network structure, construction of a training set and network training, and performance analysis. The variable time delay system described in the method comes from a countercurrent energy exchange thermodynamic process in a non-isothermal plug flow tubular reactor with a reflux device. The steam recovery device at the outlet of the reactor reduces the energy consumption for maintaining the jacket temperature by recovering heat energy to the jacket, and the spatially varying time delay comes from the transmission effect of heat energy during reflux. The analytical controller adopts the backstepping method, first constructs a proper coordinate transformation to convert the original system into a simpler target system without time delay, designs a feedback controller based on the stability of the target system, and then applies the control law to the original system through coordinate inverse transformation. The deep operator network is different from the general deep neural network, and its special network structure ensures the characteristics in the continuous space, and the learning target is the global mapping in the space. The main structure includes a branch network for extracting the characteristics of the input function, and a trunk network responsible for encoding the input function coordinates. The outputs of the two sub-networks are calculated by point multiplication to obtain the output on the discrete coordinates, and finally the feature vector is converted into a scalar of the controller output through the fully connected layer. The training of the neural operator network first needs to construct a random time delay function based on Chebyshev polynomials and the required system state. Such functions can ensure that the error is not concentrated in certain specific areas when approximating functions, but is evenly distributed in the entire interval, which is particularly suitable for fitting curves and optimization problems. Secondly, based on the broadcast mechanism, the system time delay function and the current system state are expanded to the same dimension, and the superimposed result is used as the reference input of the deep operator network. Finally, the smooth L1 norm is used as the loss function for training, which balances the smoothness of the target function and the robustness to abnormal points. When using the trained neural operator controller, only the time delay function describing the reflux device and the state at the previous time are superimposed and input into the deep operator network, and the controller output at the current time delay can be directly obtained.
[0073] As another specific embodiment, the following steps are described in detail.
[0074] Step one: build a plug flow tubular reactor system model with reflux function;
[0075]
[0076] where, with 0 < s < q < 1, x(s, t) is the steam temperature at position s inside the reactor at time t, and h(s, q) is the time delay function and:
[0077]
[0078] where max h(s, q) is the maximum value of the time delay function, and τ' is the derivative of the time delay function with respect to space; f(s, q) ∈ C 1 [0, 1] is defined as the heat transfer coefficient inside the reactor, and c(s) ∈ C 1 [0, 1] is the temperature decay coefficient, and c(1) = 0; the boundary controller U(t) is applied at the position x(0, t) to compensate for the spatially varying time delay; x(0, t) represents the reactor inlet; x(1, t - τ(s)) represents the temperature of the refluxing steam; x0(s) represents the temperature distribution at t = 0; x(s, h) = 0 is used to ensure that the reactor temperature starts from a certain initial value.
[0079] Step 2: Design the analytical time delay compensation controller. By the classical backstepping design idea, the time delay compensation controller for the above system can be represented as:
[0080]
[0081] where the function set
[0082] Step 3: Construct the structure of the deep operator network. Figure 3 An improved DeepONet framework is shown. The upper half is the branch network, which contains 3 convolutional layers, each using a convolutional filter with a kernel size of 5 and a step size of 2. In addition, this part also includes two fully connected layers with sizes of 1152 x 512 and 512 x 256. Since τ(s), x(s), and u(s, r) have different input dimensions as the branch network, τ(s) and x(s) need to be expanded to 2 dimensions along the r-axis, and the expanded τ(s) and x(s) are stacked with u(s, r) sampled on a 21 x 21 grid to obtain a 3 x 21 x 21 tensor as the input of the neural operator network. Figure 3 The lower half of is the backbone network, which encodes the input function in discrete space, i.e., (s, r) ∈ [0, 1] 2The spatial variable is sampled with a step size of 0.05 on a grid of size 100x100, transforming the spatial variable into a high-dimensional feature representation. The width of the last hidden layer of the trunk network and the branch network is 256, so the outputs of the two subnetworks can be combined into a new vector, and then the intermediate vector is passed through multiple fully connected layers to output a scalar of size 1.
[0083] Step four: generation of the dataset. The controller in equation 3 indicates that the inputs to the neural operator approximating the target need to include the time delay τ(s), the state x(s), and the delayed state u(s, r). The inputs to the neural network determine the upper bound of the output accuracy, so for The time delay function of the controller is taken from a class of Chebyshev polynomials, i.e. where Γ1 ~ U[0, 8]. This family of functions exhibits significant parameter sensitivity, and the oscillation frequency of the polynomials is controlled by Γ1. Their orthogonal properties and rapid convergence make them very effective in approximating complex functions. By generating data using Chebyshev polynomials, it can be ensured that the generated data covers various behavior patterns of the target function, which is beneficial for the neural operator to learn the potential mapping from a larger unknown space. For To meet the assumption, define the function family where and Γ2 ~ U[0.8, 2.4]. But the state u is essentially a past version of x, in order to avoid searching for the nonlinear mapping between the input function and the controller in an excessively large function space, reduce the size of the dataset, the present application extracts two state variables x(s, t i ), u(s, r, t i ) from the trajectory of the initial system state x0 acted on by the analytical controller U(t), where i = 1, 2, 3, … Specifically, for any set (x0, τ) randomly generated by Chebyshev polynomials, the dynamic response trajectory of the state x can be generated by the controller in equation 3, and the two states at different times are taken out according to the time step Δt for t ∈ [0, 12], and combined with the time delay function to form a set of inputs (τ, x, u).
[0084] Step five: training the network to obtain the neural operator. The neural network structure contains 3 million parameters, and after 250 epochs (about 3 hours using an NVIDIA RTX 4090 GPU), the test error is 5.89E-4. This training method uses the smooth L1 norm as the loss function, which combines the advantages of L1 norm and L2 norm, has more robustness to outliers than L2 norm, and avoids the problem of non-differentiability at zero of L1 norm.
[0085] Figure 2 The flow chart of using the neural operator controller to replace the numerical solution controller is shown, since the mapping of the nonlinear operator is directly learned, the input function and the discrete coordinates can be directly introduced into the neural operator to obtain the controller input at this moment, without numerical solving of the kernel function and the analytical controller, at least two digits of calculation speedup are achieved. The effect of the neural operator controller in the steam cycle process of the plug flow reactor is shown as Figure 4 indicated, the first column is the dynamic response process of the state x of the two analytical controller branches in processing the time delay respectively, the second column shows the corresponding dynamic response process obtained by using the neural operator controller, and the third column is the result of the neural operator controller after adding Gaussian noise in the input. It can be found that the neural operator controller obtained using the noise-free data set has good anti-noise ability.
[0086] The embodiment has the following beneficial effects:
[0087] The neural operator controller proposed in the embodiment uses 800,000 offline numerical solutions, and the training time is about 3 hours, which can approximate the nonlinear mapping between the time delay in the reflux device and the controller output of the reactor with an accuracy of 10 -2 -6 orders of magnitude. The greatest advantage is that once the operator describing the mapping is learned, for any time delay function not exceeding the amplitude of the training set samples, only the time delay function, the discrete value of the system state and the corresponding coordinates need to be introduced into the neural operator network to quickly calculate the controller, without the need for re-computation using numerical solvers such as finite difference method. Experiments show that the present application can achieve at least two digits of calculation speedup. And when the discrete space step of the system is further reduced, the numerical solving method often leads to explosive growth of calculation time due to interpolation and iteration operations, while the time for calculating the controller using the neural operator depends only on the number of neurons in the neural network, and the latter can fully utilize the parallel operation of the image processor (GPU) to achieve calculation speedup. At the same time, this is particularly convenient for controllers with multiple branches, as long as the rate of change of the input parameter at the boundary of each branch is guaranteed to have an upper bound, all controller branches can be represented by a neural operator, without the need to select the corresponding kernel function and controller according to the control position or the amplitude of the time delay function, greatly simplifying the calculation process of the time delay compensation controller, so the method proposed in the present application is suitable for real-time control of systems with varying parameters and time delays. In addition, after adding Gaussian noise with a variance of 0 and a mean of 5% of the amplitude, the neural operator trained using noise-free data also has excellent anti-noise ability, because the neural network structure can learn more complex features from the data, and has good robustness, thereby enabling adaptive adjustment in unknown or uncertain environments, adapting to dynamic changes.
[0088] The various embodiments described in this specification are intended to be exemplary only. The various embodiments were chosen and described in order to best explain the principles of the application and its practical application, to thereby enable others skilled in the art to best utilize the application, various embodiments with various modifications as are suited to the particular use contemplated.
[0089] The principles and implementations of the present application have been described in the specification with reference to specific examples. The above description is only used to help understand the core idea of the present application; at the same time, for those skilled in the art, according to the idea of the present application, the specific implementation and application range will be changed. In view of the above, the content of the specification should not be understood as a limitation of the present application.
Claims
1. A method for constructing a deep neural operator controller with a reflux device reactor, characterized in that: include: Based on a plug-flow tubular reactor system model with reflux function, a time-delay compensation controller system is designed as the learning objective of the neural operator controller. Determining a time-delay function according to the time-delay compensation controller system model, using the time-delay function as an input of a deep operator network, and designing a deep operator network for nonlinear mapping; generating an initial state of a dynamic response based on a Chebyshev polynomial, extracting a state of an input from the dynamic response, and determining a training data set based on the state function; The deep operator network is trained using the training data set, and the test set is used to verify that the deep operator network can stabilize a distributed parameter system described by a partial differential equation (PDE) with spatially varying time delays, thereby completing the construction of a deep neural operator controller. The functional representation of the plug flow tubular reactor system model with reflux function is specifically: x(0,t)=U(t), x(s,0)=x0(s), in, is a dimensionless position, which needs to satisfy 0≤s≤q≤1; the state x(s,t) is the steam temperature at position s inside the reactor and time t, and the time lag function And: Definition in represents the maximum value of the time-delay function, τ′ represents the derivative of the time-delay function with respect to space; f(s,q)∈C 1 [0,1] is defined as the heat transfer coefficient in the reactor, c(s)∈C 1 [0,1] represents the temperature attenuation coefficient, and c(1) = 0; the boundary controller U(t) is applied at the position x(0,t) to compensate for the spatially varying time lag; x(0,t) represents the reactor inlet; x(1,t-τ(s)) represents the temperature of the reflux steam; x0(s) represents the temperature distribution at time t = 0; x(s,h) = 0 means that before t < 0, the reactor temperature is zero; The construction process of the time-delay compensation controller system model includes: Based on the classic idea of processing delay, we first introduce a two-dimensional transmission PDE and the time delay in the hidden state, and obtain: x(0,t)=U(t), u(s,1,t)=x(1,t), x(s,0)=x0(s), Among them, u(s,r)∈L2([0,1] 2 ) represents the time-delay state variable, and the system is constructed with the state variable u, whose solution satisfies the following equation: The newly introduced state u(s, r, t) can decouple the time delay in the term x(1, t-τ(s)). Since the cascade system is equivalent to the original target system, an equivalent time delay compensation controller system model is designed for the original system of the plug flow tubular reactor system model with reflux function based directly on PDE. Based on the backstepping method, the state feedback of the time-delay system is designed and the affine Volterra integral transform is introduced: Where z(s,t) is the state variable of the stable target system; x(s,t) and u(s,r,t) are the state variables of the original system; K(s,q) is the kernel function system of the backstepping method; c(q) represents the temperature attenuation coefficient in the reactor; τ(q) represents the time lag function that varies with space; δ(q) represents the impulse function. This transformation results in the following stable target system: z(0,t)=0, u(s,1,t)=z(1,t) Therefore, the kernel function should satisfy the following equation: Boundary conditions are determined based on spatial location: Where g(q) := q-τ(q), and the maximum value in the region q∈[0,1] is defined as In order to ensure the existence of its inverse function, it is assumed that When q>τ(q), the derivative τ′(q) of the time lag function τ(q) is less than 1; At the same time, the controller generates the following two branches according to the amplitude of the time lag: Among them, the function set 2. The method for constructing a deep neural operator controller with a reflux device reactor according to claim 1, characterized in that: The structure of the deep operator network specifically includes: Branch networks and backbone networks connected in sequence; The branch network contains 3 convolutional layers, each of which uses a convolutional filter with a kernel size of 5 and a stride of 2. The branch network also includes two fully connected layers with sizes of 1152×512 and 512×256 respectively. Since τ(s), x(s) and u(s,r) are different input dimensions of the branch network, it is necessary to expand τ(s) and x(s) to 2 dimensions along the r axis, and stack the expanded τ(s) and x(s) with u(s,r) sampled on a 21×21 grid to obtain a 3×21×21 tensor as the input of the neural operator network. The backbone network is used to encode the input function in a discrete space, that is, in (s,r)∈[0,1] 2 The spatial variables are converted into a high-dimensional feature representation by sampling on the grid with a spatial step size of 0.05; The width of the last hidden layer of the branch network and the trunk network is 256, so the outputs of the two sub-networks are synthesized into a new vector, and then the intermediate vector passes through multiple fully connected layers to output a scalar of size 1.
3. The method for constructing a deep neural operator controller with a reflux device reactor according to claim 1, characterized in that: The method for determining the training data set is: According to the two branch expressions generated by the controller, the input of the neural operator for training the approximate target needs to include: time delay τ(s), state x(s) and time-delayed state u(s,r); the input of the neural network determines the upper limit of the output accuracy, so for The time-delay function of the controller is taken from a class of Chebyshev polynomials, namely in Γ1~U[0,8]; the function family shows significant parameter sensitivity, and the oscillation frequency of the polynomial is controlled by Γ1. By using Chebyshev polynomials to generate data, it is ensured that the generated data covers various behavior modes of the target function; for In order to satisfy the assumption, we define the function family in And Γ2~U[0.8,2.4]; However, for the input state variables x(s) and u(s,r), the two show correlation, that is, the state u is actually the past version of x. In order to avoid searching for the nonlinear mapping between the input function and the controller in an overly large function space and reduce the size of the data set, the two state variables x(s,t i ), u(s,r,t i ), where i = 1, 2, 3, ..., specifically, for any set (x0, τ) randomly generated by the Chebyshev polynomial, a dynamic response trajectory about the state x is generated by the controller, and the trajectory of t∈[0,12] is taken out of two states at different times according to the time step Δt, and a set of inputs (τ, x, u) is formed in combination with the time lag function to obtain the training data set.
4. The method for constructing a deep neural operator controller with a reflux device reactor according to claim 1, characterized in that: In the process of training the deep operator network using the training data set, after 250 epochs, the test error is 5.89E-4.
5. The method for constructing a deep neural operator controller with a reflux device reactor according to claim 1, characterized in that: In the process of training the deep operator network using the training data set, a smooth L1 norm is used as a loss function.