Construction method of deep neural operator controller with reflux device reactor

Abstract

The invention discloses a construction method of a deep neural operator controller with a reflux device reactor, and relates to the technical field of distributed parameter system control. The method comprises the following steps: determining a time delay compensation controller based on a plug flow tubular reactor system model with a backflow function; determining the time delay function and the system state as the input of a depth operator controller according to the time delay compensation controller; generating an initial state and a time delay function required by dynamic response based on a Chebyshev polynomial; state input and controller reference output at different moments are extracted from the dynamic response to construct a training data set; and setting appropriate neural network parameters for a neural operator controller represented by the deep neural network, and training the deep operator controller by using the training data set. The method can improve the calculation speed of the controller, and can be applied to real-time control of system parameters and time-delay changes.

Description

Technical Field

[0001] The present invention relates to the technical field of nonlinear system control, and in particular to a method for constructing a deep neural operator controller with a reactor having a reflux device. Background Art

[0002] In chemical engineering, plug-flow tubular reactors are usually equipped with recycle devices to improve reaction efficiency, conversion rate and control temperature. The steam temperature in the reactor varies with position and time. The recycle system adjusts the temperature by reintroducing part of the steam into the reactor to meet the expected process requirements. The inflow of the reactor is given by the controller. Generally speaking, the controller is robust, but even a slight time delay will still challenge the response speed of the system and even cause system instability. Therefore, it is necessary to compensate for the time delay caused by this transmission effect. The current time delay compensation controller is mainly obtained by tedious calculations through numerical solution methods, and the calculation time of this method will explode with the improvement of spatial sampling accuracy. Especially for the case where the system time delay is non-constant, it is necessary to additionally calculate the term for time delay compensation in the controller.

[0003] Neural networks (NN) are often used to directly approximate a certain type of function from input and output, while the latest deep operator network (DeepONet) can learn the mapping between infinite-dimensional functions based on the former, and has stronger self-learning ability, nonlinear mapping ability and modeling ability for complex dynamic systems. At present, the use of deep operator networks to solve control problems of nonlinear systems mainly focuses on dealing with cases with no time delay or constant time delay. The learning target is the backstepping kernel function, and then the learned kernel function is used for numerical solution method to calculate the controller gain. This is an indirect method to improve the solution efficiency. However, when the time delay varies with space, the selection of controller branches, interpolation and iterative operations still require a lot of computing time. Summary of the invention

[0004] The object of the present invention is to provide a method for constructing a deep neural operator controller with a reflux device reactor, which can improve the solution speed of the controller.

[0005] To achieve the above object, the present invention provides the following solutions:

[0006] A method for constructing a deep neural operator controller with a reflux device reactor, comprising:

[0007] Based on the plug flow tubular reactor system model with reflux function, a time-delay compensation controller system model is constructed;

[0008] Determine a time-delay function according to the time-delay compensation controller system model, use the time-delay function as an input of a deep operator network, and construct a deep operator network of nonlinear mapping;

[0009] generating an initial state of a dynamic response based on a Chebyshev polynomial, extracting an input state function from the dynamic response, and determining a training data set based on the state function;

[0010] The deep operator network is trained using the training data set, and the test set is used to verify that the deep operator network is capable of stabilizing a class of distributed parameter systems described by partial differential equations (PDEs) with spatially varying time-delays, thereby completing the construction of a deep neural operator controller.

[0011] Optionally, the functional representation of the plug flow tubular reactor system model with reflux function is specifically:

[0012]

[0013] x(0,t)=U(t),

[0014] x(s,0)=x0(s),

[0015]

[0016] in, is a dimensionless position, which needs to satisfy 0≤s≤q≤1; the state x(s,t) is the steam temperature at the position s inside the reactor at time t, and the time lag function And: Definition

[0017]

[0018] 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 time lag of spatial variation; 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 t = 0; x(s,h) = 0 means that before t<0, the reactor temperature is zero.

[0019] Optionally, the process of constructing the time-delay compensation controller system model includes:

[0020] Based on the classic idea of ​​processing delay, we first introduce a two-dimensional transmission PDE, the time delay in the hidden state, and obtain:

[0021]

[0022] x(0,t)=U(t),

[0023]

[0024] u(s,1,t)=x(1,t),

[0025] x(s,0)=x0(s),

[0026]

[0027] 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:

[0028]

[0029] 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 directly based on PDE.

[0030] Based on the backstepping method, the state feedback is designed for the time-delay system, and the affine Volterra integral transformation is introduced:

[0031]

[0032] Among them, 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 pulse function; the following stable target system is obtained through this 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:

[0038]

[0039] Boundary conditions are determined based on spatial location:

[0040]

[0041] 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, assume that When q>τ(q), the derivative τ'(q) of the lag function τ(q) is <1.

[0042] At the same time, the controller will generate the following two branches according to the amplitude of the time lag:

[0043]

[0044] Among them, the function set

[0045] Optionally, the structure of the deep operator network specifically includes:

[0046] Branch networks and trunk networks connected in sequence;

[0047] 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 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;

[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 synthesized into a new vector, and then the intermediate vector passes through multiple fully connected layers to output a scalar of size 1.

[0049] Optionally, the method for determining 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, 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 essentially 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 at different times) are extracted from the trajectory of the initial system state x0 under the action of the analytical controller U(t). i ), u(s,r,t i ), where i = 1, 2, 3, ..., specifically, for any set (x0, τ) randomly generated by Chebyshev polynomials, 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 smoothed 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 present invention discloses a method for constructing a deep neural operator controller of a reactor with a reflux device, the method comprising constructing a time-delay compensation controller system model based on a plug flow tubular reactor system model with a reflux function; determining a time-delay function according to the time-delay compensation controller system model, taking the time-delay function as the input of a deep operator network, and constructing a deep operator network of nonlinear mapping; generating an initial state of a dynamic response based on Chebyshev polynomials, extracting an input state function from the dynamic response, and determining a training data set based on the state function; and training the deep operator network using the training data set. Verified by the test set, the present invention can improve the solution speed of the controller while ensuring the control accuracy. BRIEF DESCRIPTION OF THE DRAWINGS

[0055] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings required for use in the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying creative labor.

[0056] Figure 1 This is a control schematic diagram of the plug flow tubular reactor in this embodiment;

[0057] Figure 2 This is a flow chart of the numerical solution controller and the deep neural operator controller in this embodiment;

[0058] Figure 3 Schematic diagram of the deep operator network structure for implementing the neural operator in this embodiment;

[0059] Figure 4 The approximate effect and noise resistance when the neural operator controller is applied in this embodiment;

[0060] Figure 5 Schematic diagram of the process of constructing a deep neural operator controller in this embodiment. DETAILED DESCRIPTION

[0061] The following will be combined with the drawings in the embodiments of the present invention to clearly and completely describe the technical solutions in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

[0062] The object of the present invention is to provide a method for constructing a deep neural operator controller with a reflux device reactor, which can improve the solution speed of the controller.

[0063] In order to make the above-mentioned objects, features and advantages of the present invention more obvious and easy to understand, the present invention is further described in detail below with reference to the accompanying drawings and specific embodiments.

[0064] like Figure 1-Figure 5 As shown, the present invention provides a method for constructing a deep neural operator controller with a reflux device reactor, comprising:

[0065] Step 100: Based on the plug flow tubular reactor system model with reflux function, a time-delay compensation controller system model is constructed.

[0066] Step 200: Determine a time-delay function according to the time-delay compensation controller system model, use the time-delay function as an input of a deep operator network, and construct a deep operator network for nonlinear mapping.

[0067] Step 300: Generate an initial state of a dynamic response based on Chebyshev polynomials, extract an input state function from the dynamic response, and determine a training data set based on the state function.

[0068] Step 400: Use the training data set to train the deep operator network, and evaluate the trained neural operator controller through a test set, and determine the network that meets the stability requirements as the deep neural operator controller.

[0069] Based on the above technical solution, the following is provided: Figure 2-Figure 4 The embodiment shown.

[0070] As a specific application process of plug flow tubular reactor, Figure 1 As shown, the reactants flow into the reactor from the left, and the inflow is given by the controller U(t). The jacket around the reactor is used to control the temperature inside the reactor and adjust the heating or cooling of the steam during the reaction. The state x(s,t) represents the steam temperature at position s and time t inside the reactor. It is a time variable, and its state will change with the length of the pipeline and time. x(0,t) and x(1,t) are the steam temperatures at the inlet and outlet of the reactor, respectively, and s∈[0,1] is a dimensionless position. At the same time, part of the steam will re-enter the reactor through the reflux pipeline. This reflux mechanism helps to control the temperature uniformity in the reactor and optimize heat transfer. The temperature of the reflux steam is expressed as x(1,t-τ(s)), where τ(s) is the delay time caused by the transmission distance, which depends on the pipeline length and flow rate.

[0071] The present embodiment aims to provide a neural operator control method for a partial differential system whose stabilization target is a time-delay varying partial differential system. This method uses a variable time-delay function and a system state as inputs to a neural operator network, and directly trains the controller of the system through a deep operator network, thus avoiding the selection of controller branches and various tedious numerical calculations, and greatly speeding up the solution of the controller.

[0072] As a specific implementation method, a deep neural operator controller with a reactor having a reflux device provided in this embodiment includes the mechanism modeling of a variable time-delay system, the design of an analytical controller, the construction of a deep operator network structure, the construction of a training set, the training of a network, 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 of maintaining the jacket temperature by recovering heat energy to the jacket, and the time lag that varies with space comes from the transmission effect of heat energy during reflux; the analytical controller adopts the idea of ​​backstepping, first constructs an appropriate coordinate transformation, transforms the original system into a simpler, time-delay-free target system, designs a feedback controller based on the stability of the target system, and then applies the control law to the original system through an inverse coordinate transformation; the deep operator network is different from a general deep neural network, and its special network structure ensures the characteristics in a continuous space, and the learning goal is a global mapping in space. The main structure includes: a branch network (branch net) for extracting the characteristics of the input function, and a trunk network (trunk net) responsible for encoding the coordinates of the input function. The outputs of the two sub-networks are calculated by dot product to obtain the outputs on the corresponding discrete coordinates, and finally the feature vectors are converted into scalars of the controller output through the fully connected layer; the training of the neural operator network first requires the construction of random time-delay functions and the required system states based on Chebyshev polynomials. This type of function ensures that the error will not be concentrated in certain specific areas when approximating the function, but is more evenly distributed in the entire interval, which is particularly suitable for fitting curves and optimization problems. Secondly, the system time-delay function and the current system state are extended to the same dimension based on the broadcast mechanism, 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 objective function and the robustness to abnormal points. When using the trained neural operator controller, it is only necessary to superimpose the time-delay function describing the reflux device and the state of the previous moment into the deep operator network to directly obtain the controller output of the current time delay.

[0073] Another specific implementation method is described in detail with the following steps.

[0074] Step 1: Construct a plug flow tubular reactor system model with reflux function;

[0075]

[0076] in, It needs to satisfy 0≤s≤q≤1, the state x(s,t) is the steam temperature at the position s inside the reactor at time t, and the time lag function and:

[0077]

[0078] 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 time lag of spatial variation; 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 t = 0; x(s,h) = 0 is used to ensure that the reactor temperature starts from a certain initial value.

[0079] Step 2: Design an analytical time-delay compensation controller. Using the classic backstepping design concept, the time-delay compensation controller of the above system can be expressed as:

[0080]

[0081] Among them, the function set

[0082] Step 3: Build the structure of the deep operator network. Figure 3 An improved DeepONet framework is presented. The upper part is a branch network, which contains 3 convolutional layers, each of which uses a convolutional filter with a kernel size of 5 and a stride of 2. In addition, this part 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. Figure 3 The lower part of the network is the backbone network, which encodes the input function in discrete space, that is, in (s,r)∈[0,1] 2The 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 main network and the branch network is 256, so the outputs of the two sub-networks can be synthesized 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 4: Generation of data set. The controller in Equation 3 indicates that 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]. This family of functions exhibits significant parameter sensitivity. The oscillation frequency of the polynomial is controlled by Γ1. Their orthogonal properties and fast convergence make them very effective in approximating complex functions. By using Chebyshev polynomials to generate data, it can be ensured that the generated data covers a variety of behavior modes of the target function, which is conducive to the neural operator learning potential mappings from a wider range of unknown spaces. For In order to satisfy the assumption, define the function family in And Γ2~U[0.8,2.4]. However, 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 present invention extracts two state variables x(s,t at different times) from the trajectory of the initial system state x0 under the action of the analytical controller U(t). i ), u(s,r,t i ), where i = 1, 2, 3, ..., specifically, for any set (x0, τ) randomly generated by Chebyshev polynomials, the controller in Equation 3 can generate a dynamic response trajectory about the state x, 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-delay function.

[0084] Step 5: Train the network to obtain neural operators. The neural network structure contains 3 million parameters, and after 250 epochs (running for 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 the L1 norm and the L2 norm. It is more robust to outliers than the L2 norm, while avoiding the problem that the L1 norm is not differentiable at zero.

[0085] Figure 2 The flowchart of using a neural operator controller to replace a numerical solution controller is shown. Since the mapping of nonlinear operators is directly learned, the input function and discrete coordinates can be directly imported into the neural operator to obtain the controller input at that moment, without the need to numerically solve the kernel function and analytical controller, achieving at least a double-digit computational acceleration. The effect of using a neural operator controller in the steam cycle of a plug flow tubular reactor is shown in Figure 2. Figure 4 As shown in the first column, the two analytical controller branches belong to The first column shows the dynamic response process of state x when the neural operator controller is used. The second column shows the corresponding dynamic response process obtained by using the neural operator controller. The third column is the result of adding Gaussian noise to the input of the neural operator controller. It can be found that the neural operator controller obtained using the noise-free data set has better noise resistance.

[0086] This embodiment has the following beneficial effects:

[0087] The neural operator controller proposed in this embodiment uses 800,000 offline numerical solutions and takes about 3 hours to train. -2 The nonlinear mapping between the time lag in the reflux device and the controller output of the reactor is approximated with an order of magnitude accuracy. Its greatest advantage is that once the operator describing the mapping is learned, for any time lag function that does not exceed the sample amplitude of the training set, it is only necessary to import the time lag function, the discrete value of the system state, and the corresponding coordinates into the neural operator network to quickly calculate the controller, and it is no longer necessary to use a numerical solver such as the finite difference method for recalculation. Experiments have shown that the present invention can achieve at least a double-digit calculation acceleration. And when the spatial step size of the system discreteness becomes smaller, the numerical solution method often causes an explosive growth in calculation time due to interpolation and iterative operations, while the time to calculate the controller using a neural operator depends only on the number of neurons in the neural network, and the latter can make full use of the parallel operation of the image processing unit (GPU) to achieve calculation acceleration. At the same time, this is particularly convenient for controllers with multiple branches. It is only necessary to ensure that there is an upper bound on the rate of change of the input parameters at the boundary of each branch, and a neural operator can be used to characterize all controller branches. There is no need to select the corresponding kernel function and controller according to the control position or the amplitude of the time-delay function, which greatly simplifies the calculation process of the time-delay compensation controller. Therefore, the method proposed in the present invention is suitable for real-time control of system parameters and time-delay changes. In addition, after adding Gaussian noise with a variance of 0 and a mean of 5% of the amplitude, the neural operator trained with noise-free data also has excellent noise resistance. This is because the neural network structure can learn more complex features from the data and naturally has better robustness, thereby realizing adaptive adjustment in unknown or uncertain environments and adapting to dynamic changes.

[0088] The various embodiments in this specification are described in a progressive manner, and each embodiment focuses on the differences from other embodiments. The same or similar parts between the various embodiments can be referenced to each other.

[0089] This article uses specific examples to illustrate the principles and implementation methods of the present invention. The above examples are only used to help understand the core idea of ​​the present invention. At the same time, for those skilled in the art, according to the idea of ​​the present invention, there will be changes in the specific implementation methods and application scope. In summary, the content of this specification should not be understood as limiting the present invention.

Claims

1. A method for constructing a deep neural operator controller with a reflux device reactor, characterized in that: include: Based on the plug flow tubular reactor system model with reflux function, a time-delay compensation controller system is designed as the learning target of the neural operator controller. Determine a time-delay function according to the time-delay compensation controller system model, use the time-delay function as an input of a deep operator network, and design a deep operator network of 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 is capable of stabilizing a class of distributed parameter systems described by partial differential equations (PDEs) with spatially varying time-delays, thereby completing the construction of a deep neural operator controller.

2. The method for constructing a deep neural operator controller with a reflux device reactor according to claim 1, characterized in that: 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 the position s inside the reactor at 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 time lag of spatial variation; 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 t = 0; x(s,h) = 0 means that before t<0, the reactor temperature is zero.

3. The method for constructing a deep neural operator controller with a reflux device reactor according to claim 2, characterized in that: 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, 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 directly based on PDE. Based on the backstepping method, the state feedback is designed for the time-delay system, and the affine Volterra integral transformation is introduced: Among them, 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 pulse function; the following stable target system is obtained through this transformation: 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, assume that When q>τ(q), the derivative τ'(q) of the lag function τ(q) is <1. At the same time, the controller will generate the following two branches according to the amplitude of the time lag: Among them, the function set 4. 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 trunk 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 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.

5. The method for constructing a deep neural operator controller with a reflux device reactor according to claim 3, 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, 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 essentially 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 at different times) are extracted from the trajectory of the initial system state x0 under the action of the analytical controller U(t). i ), u(s,r,t i ), where i = 1, 2, 3, ..., specifically, for any set (x0, τ) randomly generated by Chebyshev polynomials, 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.

6. 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.

7. 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 smoothed L1 norm is used as a loss function.

Images