Intelligent low-code development method and system based on deep learning model optimization

Abstract

The invention discloses an intelligent low-code development method and system based on deep learning model optimization, and relates to the technical field of deep learning. A multi-dimensional domain knowledge graph is constructed, a three-dimensional space-time fusion training sample set is constructed based on the domain knowledge graph, and cross-modal feature alignment is performed on the training sample set, so that the multi-dimensional domain knowledge graph is constructed; the method comprises the following steps: generating an executable logic flow template, encoding the executable logic flow template into a Markov decision process, and performing joint strategy optimization on an optimization target of logic flow by integrating a feature importance index generated by a gradient back propagation path and a multi-target reinforcement learning framework of a Pareto leading edge analysis module. Extracting a strategy parameterization sequence after joint strategy optimization, injecting the strategy parameterization sequence into a dynamic verification sandbox environment, and performing abnormal mode detection and feedback type parameter distillation iteration on an execution track through an online variational auto-encoder to complete dynamic adjustment of the strategy; and the elasticity, the stability and the expandability of the low-code platform are improved.

Description

Technical Field

[0001] The present invention relates to the technical field of deep learning, and specifically to an intelligent low-code development method and system based on the optimization of deep learning models. Background Art

[0002] In modern low-code platforms, as the complexity of enterprise business increases, low-code platforms have gradually become key tools for enterprise digital transformation. Low-code platforms simplify the application development and deployment processes through graphical interfaces, enabling business personnel to also participate in development, reducing development costs and time. However, with the complication of business scenarios and the improvement of system performance requirements, traditional low-code platforms are faced with the problem of how to maintain flexibility and efficiency in the changing business requirements and technical environment. Especially in key links such as business process optimization, resource scheduling, and decision execution, low-code platforms often lack sufficient intelligent decision support and automated strategy optimization mechanisms, resulting in the inability of the system to efficiently adapt to business changes during large-scale applications or to quickly make adjustments in a dynamic environment.

[0003] In the prior art, low-code platforms usually rely on static rules or predefined decision models for the deployment and execution of logic flows. This method often has difficulty dealing with complex multi-objective optimization scenarios and cannot automatically adjust resource allocation and processing strategies in large-scale systems; traditional automated deployment and resource scheduling methods are usually based on fixed configurations and lack the ability to make real-time adjustments according to dynamic factors such as business load and resource requirements. This causes the platform to often experience performance bottlenecks or resource waste when facing large-scale data and business fluctuations;

[0004] Therefore, the present invention proposes an intelligent low-code development method and system based on the optimization of deep learning models. Summary of the Invention

[0005] The present invention aims to solve at least one of the technical problems existing in the prior art. For this purpose, the present invention proposes an intelligent low-code development method and system based on the optimization of deep learning models, which improves the elasticity, stability, and scalability of the low-code platform.

[0006] To achieve the above object, an intelligent low-code development method based on the optimization of deep learning models is proposed, including the following steps:

[0007] Step 1: Construct a multi-dimensional domain knowledge graph through domain-driven meta-modeling technology;

[0008] Step 2: Based on the domain knowledge graph, construct a three-dimensional spatio-temporal fusion training sample set, and use a Transformer-GNN hybrid architecture to perform cross-modal feature alignment on the training sample set to generate an executable logic flow template carrying semantic constraints;

[0009] Step 3: Encode the executable logic flow template into a Markov decision process, and jointly optimize the optimization objectives of the logic flow of the Markov decision process through the feature importance index generated by the integrated gradient backpropagation path and the multi-objective reinforcement learning framework of the Pareto front analysis module;

[0010] Step 4: Extract the policy parameterized sequence after the joint policy optimization, inject it into the dynamic verification sandbox environment constructed by the runtime monitoring module, and perform anomaly pattern detection and feedback parameter distillation iteration on the execution trajectory through an online variational autoencoder to complete the dynamic adjustment of the policy;

[0011] Step 5: Automatically and elastically deploy the dynamically verified policy parameterized sequence to the target service;

[0012] The construction of a multi-dimensional domain knowledge graph through domain-driven meta-modeling technology includes the following steps:

[0013] Step 101: Define domain entity types, attributes, and relationship constraints through a visual meta-model editor, call a pre-trained multi-modal alignment model to perform cross-modal semantic matching on structured database fields and unstructured document terms, generate an entity-attribute mapping table with confidence annotations, and achieve the alignment of domain meta-model definition and heterogeneous data;

[0014] Step 102: Based on the entity-attribute mapping table, train a domain-specific entity recognition model using a joint learning framework, extract structured event triples from business logs, calculate entity interaction weights through a time-series decay function, and construct a functional topology network with dynamic edge weights to achieve dynamic entity relationship extraction and topology network construction;

[0015] Step 103: Parse the business rules in the domain documents, convert the atomic conditions in the business rules into a sparse constraint matrix aligned with the node feature dimensions of the functional topology network, and eliminate rule conflicts through a self-attention mechanism;

[0016] Step 104: Based on the node IDs in the functional topology network and the sparse constraint matrix, perform spatio-temporal slicing on the business process logs, and use a hypergraph neural network to fuse topological features and spatio-temporal traffic patterns to generate a low-rank compressed data flow tensor to achieve spatio-temporal representation learning of the data flow tensor;

[0017] Step 105: Align the functional topology network, the sparse constraint matrix, and the data flow tensor through the message passing mechanism of the graph neural network to generate a domain knowledge graph integrating spatio-temporal and logical features, and store it in the graph database;

[0018] Based on the above-mentioned domain knowledge graph, constructing a training sample set with three-dimensional spatio-temporal fusion includes the following steps:

[0019] Step 201: Based on the adjacency matrix and node feature vectors of the functional topology network in the domain knowledge graph, use the dynamic random walk algorithm to generate entity interaction sequences;

[0020] Step 202: Map the non-zero elements of the business rule constraint matrix to spatio-temporal units, and realize the continuous space embedding of rule features through sparse tensor multiplication;

[0021] Step 203: Construct a hierarchical graph attention network, and fuse multi-source features in three stages: bottom-layer topology feature extraction, middle-layer spatio-temporal feature fusion, and top-layer rule feature injection;

[0022] Step 204: Based on the spatio-temporal index and rule constraints of the domain knowledge graph, adopt an adversarial generation strategy to construct difficult negative samples and generate a training sample set;

[0023] The above-mentioned use of the Transformer-GNN hybrid architecture to perform cross-modal feature alignment on the training sample set and generate an executable logic flow template carrying semantic constraints includes the following steps:

[0024] Step 211: Use the Transformer model to extract spatio-temporal sequence features from the training sample set;

[0025] The above-mentioned extraction of spatio-temporal sequence features includes:

[0026] Construct the training sample set into a standard sequence input according to the time and space dimensions, and use the position encoder to embed the position information of each element in the sequence to ensure that the Transformer can capture local and global spatio-temporal dependencies;

[0027] Adopt the multi-head self-attention mechanism to extract features from the input sequence, and each attention head extracts global context information from different angles to provide multi-perspective spatio-temporal features;

[0028] Stack several Transformer encoder layers, and the finally output sequence feature tensor serves as the spatio-temporal sequence features required for subsequent cross-modal fusion;

[0029] Step 212: Based on the domain knowledge graph, construct a GNN graph encoding module, and extract graph structure features through the graph encoding module;

[0030] The above-mentioned extraction of graph structure features includes:

[0031] According to the functional topology network constructed in the domain knowledge graph, using the feature vectors of each node in the domain knowledge graph as the initial features of each node, and using the adjacency matrix and dynamic edge weight information, construct a graph data structure that reflects the interaction relationship between nodes;

[0032] Select a message passing mechanism such as a graph convolutional network, a graph attention network, or a hypergraph neural network to perform multi-layer information passing on each node in the graph structure and aggregate the features of neighboring nodes; it should be noted that an edge weight dynamic update strategy is introduced during the information passing process to ensure that non-linear and time-varying relationships can be captured;

[0033] Output the node feature matrix after multi-layer aggregation and generate a global context representation for each node, and this global context representation serves as the graph structure feature;

[0034] Step 213: Fuse the spatio-temporal sequence features and the graph structure features, and generate fused features through a predefined induced signal loss function;

[0035] The generation of the fused features includes:

[0036] Adopt bilinear pooling, cross-attention mechanism, or the design of a fusion layer such as a fully connected network and a residual connection to align the spatio-temporal sequence features extracted by the Transformer with the graph structure features output by the GNN, and input the aligned spatio-temporal sequence features and graph structure features into the fusion layer;

[0037] In the fusion layer, through a predefined induced signal loss function, guide the feature representation target constraint generated by the model during backpropagation;

[0038] Output a unified cross-modal feature representation through the fusion layer as the fused feature;

[0039] Step 214: According to the fused features, construct an executable logic flow template through a decoder;

[0040] The construction of the executable logic flow template through the decoder includes:

[0041] Construct a template generation module based on the Transformer decoder or the graph decoder, and use the fused feature representation after fusion as the input;

[0042] During the decoding process, embed the constraint conditions from the domain rules, such as the resource limitations of each process node, the response delay constraints, and the exception handling rules, so that the generated template meets the actual business requirements;

[0043] Define a joint loss function including a generation loss such as cross-entropy loss, an induced signal constraint loss, and a domain consistency loss, and train according to the generation loss through a training sample set. Verify the generated template through offline simulation or small-scale online testing.

[0044] Encoding the executable logic flow template into a Markov decision process includes the following steps:

[0045] Step 311: Preprocess the input executable logic flow template, extract the business processes, decision nodes, and transition conditions described therein, and construct the state space of the Markov decision process based on the extracted business processes, decision nodes, and transition conditions.

[0046] Step 312: Identify the allowed operation options for each decision node from the parsed template to form the action space of the Markov decision process.

[0047] Step 313: Formalize the process transition relationship described in the logic flow template as the state transition function of the Markov decision process.

[0048] Step 314: Design a reward function for the Markov decision process to evaluate the immediate gain or cost obtained after taking action a in state s.

[0049] Step 315: The state space, action space, state transition function, and reward function constitute the Markov decision process.

[0050] The joint policy optimization of the optimization objectives of the logic flow of the Markov decision process through the feature importance index generated by the integrated gradient backpropagation path and the multi-objective reinforcement learning framework of the Pareto front analysis module includes the following steps:

[0051] Step 321: Take the logic flow that has been encoded into a Markov decision process as the optimization object, and use the integrated gradient method to calculate the feature importance of the backpropagation path.

[0052] Step 322: Design a Pareto front analysis module, construct a multi-objective evaluation system for domain projects, and generate weighted objective functions for each objective based on the feature importance.

[0053] Step 323: Construct a multi-objective reinforcement learning framework that integrates the Markov decision process and the multi-objective evaluation system.

[0054] Step 324: Through defining a multi-objective loss function, perform joint policy optimization according to the output of the multi-objective reinforcement learning framework.

[0055] The method of extracting the optimized policy parameterized sequence of the joint policy and injecting it into the dynamic verification sandbox environment constructed by the runtime monitoring module is as follows:

[0056] Use containerization and virtualization technologies to construct a dynamic verification sandbox environment, simulate the code running conditions consistent with the production environment, and collect system behavior data through real-time monitoring tools at the same time;

[0057] Use standard interface calls and data mapping mechanisms to inject the policy parameterized sequence into the dynamic verification sandbox environment to achieve online verification and feedback of the policy in real business scenarios;

[0058] The method of using an online variational autoencoder for anomaly pattern detection and feedback-based parameter distillation iteration of the execution trajectory is as follows:

[0059] Pre-collect the execution trajectory data of the policy execution in the dynamic verification sandbox environment and represent it as a set of trajectory sequences;

[0060] The online variational autoencoder contains an encoder and a decoder, and its training objective is to maximize the evidence lower bound;

[0061] In the dynamic verification sandbox environment, use the online variational autoencoder to reconstruct the real-time collected execution trajectory, calculate the reconstruction error, and determine whether feedback-based parameter distillation is required based on the reconstruction error;

[0062] For the execution path that requires feedback-based parameter distillation, collect the policy parameterized sequence of this execution path, define a deviation loss function that quantifies the deviation between the current policy and the policy parameterized sequence, and use the gradient descent method to update the parameters of the deviation loss function;

[0063] The method of automatically and elastically deploying the dynamically verified policy parameterized sequence to the target service is as follows:

[0064] The low-code platform receives the policy parameterized sequence obtained after online anomaly detection and feedback-based parameter distillation iteration, and converts each parameter into a specific item of the deployment configuration through predefined mapping rules;

[0065] Perform corresponding deployment on the low-code platform according to the specific items of the obtained deployment configuration.

[0066] Propose an intelligent low-code development system optimized based on a deep learning model, including a knowledge graph construction module, a logic flow template construction module, a policy optimization module, a policy dynamic adjustment module, and a policy deployment module; among them, each module is connected electrically;

[0067] The knowledge graph construction module constructs a multi-dimensional domain knowledge graph through domain-driven meta-modeling technology and sends the domain knowledge graph to the logic flow template construction module;

[0068] The logic flow template construction module constructs a training sample set that fuses three-dimensional space and time based on the domain knowledge graph, performs cross-modal feature alignment on the training sample set using a Transformer-GNN hybrid architecture, generates an executable logic flow template with semantic constraints, and sends the executable logic flow template to the policy optimization module;

[0069] The policy optimization module encodes the executable logic flow template into a Markov decision process, jointly optimizes the optimization objectives of the logic flow of the Markov decision process through the feature importance index generated by the integrated gradient backpropagation path and the multi-objective reinforcement learning framework of the Pareto front analysis module, and sends the parameterized sequence of the jointly optimized policy to the policy dynamic adjustment module;

[0070] The policy dynamic adjustment module extracts the parameterized sequence of the jointly optimized policy, injects it into the dynamic verification sandbox environment constructed by the runtime monitoring module, performs anomaly pattern detection and feedback-based parameter distillation iteration on the execution trajectory through an online variational autoencoder, completes the dynamic adjustment of the policy, and sends the dynamically adjusted policy to the policy deployment module;

[0071] The policy deployment module performs automated elastic deployment of the target service on the parameterized sequence of the dynamically verified policy.

[0072] Compared with the prior art, the beneficial effects of the present invention are:

[0073] The present invention first constructs a multi-dimensional knowledge graph through domain-driven modeling technology, extracts the key nodes and associations in the business process, and then uses a Transformer-GNN hybrid architecture to perform feature alignment on multi-modal data to generate an executable logic flow template with semantic constraints. Through integrated gradients and the Pareto front analysis module, combined with the multi-objective reinforcement learning framework, each objective in the Markov decision process is jointly optimized to find the best decision path. Through an online variational autoencoder, the execution trajectory is reconstructed in real time and anomaly patterns are detected. When a deviation from the expected execution trajectory is found, feedback is provided and the parameter distillation iteration process is triggered to automatically adjust the policy to ensure the stability and efficiency of the system during actual operation. Finally, the adjusted policy is automatically deployed; real-time optimization of the policy and flexible scheduling of resources are achieved, avoiding the static configuration problem in traditional methods, and improving the elasticity, stability, and scalability of the low-code platform. Brief Description of the Drawings

[0074] Figure 1It is a flowchart of the intelligent low-code development method optimized based on the deep learning model in Embodiment 1 of the present invention;

[0075] Figure 2 It is an example diagram of tensor change of Tucker decomposition in Embodiment 1 of the present invention;

[0076] Figure 3 It is a module connection relationship diagram of the intelligent low-code development system optimized based on the deep learning model in Embodiment 2 of the present invention. Detailed implementation manners

[0077] Next, the technical solutions of the present invention will be clearly and completely described in conjunction with the embodiments. Obviously, the described embodiments are only a part of the embodiments of the present invention, rather than all the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative efforts shall fall within the protection scope of the present invention.

[0078] In the online service platforms of modern enterprises, especially in the fields of large-scale online retail, logistics scheduling, and real-time data processing, the complexity of business processes and the dynamic changes in resource requirements require the platforms to have a high degree of adaptability and flexibility. Existing technologies often cannot effectively predict and adjust resource allocation, resulting in unstable system performance. Especially during peak business periods or when the load fluctuates greatly, resources cannot be efficiently utilized, and even service interruptions or response delays may occur. Therefore, how to achieve real-time policy optimization and resource automatic scheduling based on business data and operating status is a major technical problem faced by enterprises.

[0079] Embodiment 1

[0080] As Figure 1 shown, the intelligent low-code development method optimized based on the deep learning model includes the following steps:

[0081] Step 1: Construct a multi-dimensional domain knowledge graph through domain-driven meta-modeling technology;

[0082] Step 2: Based on the domain knowledge graph, construct a three-dimensional spatio-temporal fusion training sample set, and use a Transformer-GNN hybrid architecture to perform cross-modal feature alignment on the training sample set to generate an executable logic flow template carrying semantic constraints;

[0083] Step 3: Encode the executable logic flow template into a Markov decision process, and jointly optimize the optimization objectives of the logic flow of the Markov decision process through the feature importance index generated by the integrated gradient backpropagation path and the multi-objective reinforcement learning framework of the Pareto front analysis module;

[0084] Step 4: Extract the optimized policy parameterization sequence of the joint policy, inject it into the dynamic verification sandbox environment constructed by the runtime monitoring module, and perform anomaly pattern detection and feedback-based parameter distillation iteration on the execution trajectory through an online variational autoencoder to complete the dynamic adjustment of the policy;

[0085] Step 5: Automatically and elastically deploy the dynamically verified policy parameterization sequence to the target service.

[0086] In an embodiment of the present invention, constructing a multi-dimensional domain knowledge graph through domain-driven meta-modeling technology includes the following steps:

[0087] Step 101: Define domain entity types, attributes, and relationship constraints through a visual meta-model editor, call a pre-trained multi-modal alignment model to perform cross-modal semantic matching on structured database fields and unstructured document terms, generate an entity-attribute mapping table with confidence annotations, and achieve the alignment of domain meta-model definition and heterogeneous data;

[0088] For example, the structured database fields and unstructured document terms input in Step 101 can be Schema metadata in the domain database and API interface document description text, and the output is a standardized semantic label set and a mapping table in JSON-LD format;

[0089] The multi-modal alignment model uses a Bi-LSTM model to calculate the semantic similarity between the field names of structured data in the database and domain terms. The model input is a character-level embedding vector, and the output is a similarity score; perform TF-IDF weighted word vectorization on unstructured documents (such as API interface documents), perform cosine similarity matching with a predefined ontology library, and trigger manual review for fields with a confidence level lower than the threshold in the mapping table (for example, the similarity between "txn_date" and "transaction date" is 0.78, and the threshold is generally set to 0.8), and mark and correct through a low-code platform;

[0090] Step 102: Based on the entity-attribute mapping table, train a domain-specific entity recognition model using a joint learning framework, extract structured event triples from business logs, and calculate entity interaction weights through a time decay function to construct a functional topology network with dynamic edge weights, achieving dynamic entity relationship extraction and topology network construction;

[0091] For example, the joint learning framework uses the FLAIR framework to train a Span-based NER model. The input of the joint learning framework is the aligned business logs, and the output is entity boundaries and type labels; and the time decay function is set as weight = original interaction times × e -0.1×Δt, Δt is the time difference between the current time and the nearest interaction time corresponding to the event. Each event corresponds to an edge of a node. Then, the weights of the outgoing edges of the same node are normalized by Softmax to ensure that the sum of the weights of all edges of each node is equal to one;

[0092] Step 103: Parse the business rules in the domain document, convert the atomic conditions in the business rules into a sparse constraint matrix aligned with the node feature dimensions of the functional topology network, and eliminate rule conflicts through the self-attention mechanism;

[0093] For example, for the input contract clause text, use CoreNLP to construct a dependency syntax tree and match predefined rule templates. For example, encode the atomic condition "The transfer amount per day > 50,000 requires review" as a sparse vector, where: Condition dimension: The index position corresponding to the "transfer amount" node in the topology network is set to 1 - Threshold dimension: The 50,000 threshold position is set to -1 - Conflict resolution: Calculate the similarity between rules through the self-attention mechanism. If the similarity > 0.7 and they are logically mutually exclusive, then retain the rule with the higher priority. Specifically, the priority is marked by the business document in the domain; An example of a generated JSON-LD format mapping table is: {"source_field": "cust_id", "mapped_entity": "customer", "confidence": 0.92};

[0094] Step 104: Based on the node IDs in the functional topology network and the sparse constraint matrix, perform spatio-temporal slicing on the business process log, and use the hypergraph neural network to fuse the topological features and spatio-temporal traffic patterns to generate a low-rank compressed data flow tensor, realizing spatio-temporal representation learning of the data flow tensor;

[0095] For example, the spatio-temporal slicing dynamically adjusts the window length according to the business peak period in the domain, generating several spatio-temporal units. Each spatio-temporal unit contains a four-tuple of {source node ID, target node ID, time slice number, traffic value};

[0096] The training of the hypergraph neural network forms hyperedges by the nodes corresponding to the non-zero elements in the sparse constraint matrix (for example, if rule R1 involves nodes N1 / N2 / N3, then generate hyperedge E1), and uses a gating mechanism: design a GRU unit to control the retention rate of historical traffic features;

[0097] Finally, the tensor compression uses Tucker decomposition to compress the original tensor (size 1024×1024×1440×256) to 32% rank (output size 64×64×460×84), forming a fourth-order spatio-temporal tensor (source node × target node × time slice × feature channel), as Figure 2 shown in the example diagram of the tensor change of Tucker decomposition;

[0098] Step 105: Align the modalities of the functional topology network, the sparse constraint matrix, and the data flow tensor through the message passing mechanism of the graph neural network to generate a domain knowledge graph that fuses spatio-temporal and logical features, and store it in the graph database;

[0099] For example, define a message passing mechanism for cross-modal aggregation functions in the graph neural network to achieve modality alignment. The form of the cross-modal aggregation function is where N(i) is the set of neighbor nodes of the i-th node, and respectively represent the feature vectors of node i and its neighbor node j at the l-th layer. T ij is the spatio-temporal interaction feature between node i and j, which is derived from the spatio-temporal tensor compression result generated in Step 104. For example, it includes dynamic information such as traffic patterns (e.g., transaction frequency) within a time slice and resource consumption trends, and its dimension is aligned with the node features, thus injecting spatio-temporal features into each node; α ij is the attention weight coefficient, dynamically calculated through the attention mechanism, reflecting the importance of neighbor node j to the current node i; W is a trainable weight matrix used to perform a linear transformation on the concatenated multi-modal features to extract cross-modal implicit associations, and || is the vector concatenation symbol; thus, the feature vector of each node after fusion contains the dynamic edge weights calculated in Step 102, the constraint association strength of the corresponding rules in the sparse constraint matrix generated in Step 103, and the spatio-temporal features generated in Step 104.

[0100] In the embodiments of the present invention, constructing a training sample set for three-dimensional spatio-temporal fusion based on the domain knowledge graph includes the following steps:

[0101] Step 201: Generate entity interaction sequences using the dynamic random walk algorithm based on the adjacency matrix and node feature vectors of the functional topology network in the domain knowledge graph;

[0102] In this embodiment, it specifically includes:

[0103] Based on the time slice division rule of the data flow tensor (e.g., every 5 minutes as a time unit), cut the business log stream into continuous spatio-temporal units, and each unit contains the source node ID, target node ID, timestamp, and interaction attributes (e.g., transaction amount, response delay). During this process, the business attributes embedded in the node feature vectors (such as "account risk level" in the financial scenario) are converted into weight adjustment factors for the walking path to ensure that the appearance frequency of high-risk entities in the sampling sequence is increased by 40%-60%. For example, in the anti-money laundering scenario, apply a weight gain coefficient of 1.5 to the account nodes marked as "high risk" to significantly improve the coverage rate of relevant transaction events in the training samples;

[0104] Step 202: Map the non-zero elements of the business rule constraint matrix to spatio-temporal units, and realize the continuous space embedding of rule features through sparse tensor multiplication;

[0105] In this embodiment, it specifically includes:

[0106] For the source node and target node in each spatio-temporal unit, retrieve their corresponding row vectors and column vectors of the business rule constraint matrix, and perform the Hadamard Product operation to generate 32-dimensional rule feature vectors. In this process, utilize the orthogonality constraint between the topological network node feature dimension and the rule matrix (such as the correlation between the "single-day transfer limit" rule and the "account type" feature in the financial field) to automatically filter the superimposed interference of conflicting rules on the same spatio-temporal unit. For example, when it is detected that a certain spatio-temporal unit simultaneously triggers the "cross-border transfer requires review" and "VIP customers are exempt from review" rules, the system selects and retains the high-priority rule features according to the rule priority parameters (pre-defined in the domain knowledge graph).

[0107] Step 203: Construct a hierarchical graph attention network to fuse multi-source features in three stages: bottom-layer topological feature extraction, middle-layer spatio-temporal feature fusion, and top-layer rule feature injection;

[0108] In this embodiment, it specifically includes:

[0109] The bottom-layer topological feature extraction includes: based on the entity interaction sequence generated in Step 201, aggregate the attribute features of neighbor nodes (such as "user credit score", "device geographical location") through GAT, and output the topological embedding vector;

[0110] The middle-layer spatio-temporal feature fusion includes: splice the traffic pattern such as the number of transactions processed per second in the corresponding time slice of the data flow tensor with the topological embedding vector, and utilize the Temporal Convolutional Network (TCN) to extract the temporal dependence features;

[0111] The top-layer rule feature injection includes performing gated attention fusion on the rule feature vector generated in Step 202 and the spatio-temporal features to dynamically adjust the contribution weights of each modality;

[0112] Step 204: Based on the spatio-temporal index and rule constraints of the domain knowledge graph, adopt an adversarial generation strategy to construct difficult negative samples and generate a training sample set;

[0113] In this embodiment, it specifically includes but is not limited to:

[0114] In the functional topological network, select node pairs that are similar to the source node degree centrality of the positive sample (the difference < 0.1) but have no direct connection edges to achieve topological similarity sampling;

[0115] Retrieve events in the data flow tensor that are adjacent to the positive sample time slice (e.g., ±2 minutes), have a similar spatial distribution (e.g., cosine similarity > 0.8), but violate business rules (such as "short-term high-frequency logins from the same IP") to achieve spatio-temporal proximity interference;

[0116] Call the sparse coding result of the business rule constraint matrix to perform logical conflict detection on the generated candidate negative samples. If it triggers a rule conflict marker (such as the coexistence of "transfer amount exceeding the limit" and "payee blacklist"), then retain it as a high-value negative sample. In the supply chain finance scenario, this method increases the detection rate of the "fictitious trade background" fraud pattern by 28% for the model, achieving rule conflict enhancement;

[0117] In a further embodiment of the present invention, a double-buffer storage and incremental calculation mechanism can also be established to achieve dynamic synchronization of the training sample set and the domain knowledge graph;

[0118] Specifically, it includes that when new business logs flow in, it triggers incremental updates of the knowledge graph (such as fine-tuning of node feature vectors, change of the sparse pattern of the rule matrix), and compares the version hash value of the domain knowledge graph, which is jointly generated by the topological structure signature, the sparse pattern of the rule matrix, and the tensor decomposition basis vectors, to identify the affected spatio-temporal units, and re-execute the process of steps 201 - 204 to generate incremental samples.

[0119] In an embodiment of the present invention, the step of using a Transformer-GNN hybrid architecture to perform cross-modal feature alignment on the training sample set to generate an executable logic flow template carrying semantic constraints includes the following steps:

[0120] Step 211: Use a Transformer model to extract spatio-temporal sequence features from the training sample set;

[0121] In this embodiment, it specifically includes:

[0122] Construct the training sample set into a standard sequence input according to the time and space dimensions, and use a positional encoder to embed the position information of each element in the sequence to ensure that the Transformer can capture local and global spatio-temporal dependencies;

[0123] Adopt a multi-head self-attention mechanism to extract features from the input sequence, and each attention head extracts global context information from different perspectives to provide multi-perspective spatio-temporal features;

[0124] Stack several Transformer encoder layers, and the finally output sequence feature tensor serves as the spatio-temporal sequence features required for subsequent cross-modal fusion.

[0125] In a specific example of an online retail business, the processing process of step 211 may include:

[0126] On the premise that a domain knowledge graph has been constructed, each node in the domain knowledge graph represents key links in order processing: order verification, payment processing, inventory check, logistics scheduling, exception handling, etc.; the edges describe the dependencies between the links, such as "order verification" must be completed before "payment processing", etc.;

[0127] Using the normalized order time series data, arrange events such as "order placement", "payment confirmation", "inventory check", "logistics scheduling", etc. in chronological order, and embed a timestamp and spatial location for each event;

[0128] Use Transformer to encode the above order time series data. Through multi-head attention, the Transformer model can capture the global dependencies and potential latency risks in the domain knowledge graph. For example, if the "payment confirmation" event is delayed, subsequent "inventory check" and "logistics scheduling" may also be delayed;

[0129] The multi-layer Transformer encoder gradually extracts the global spatio-temporal dependencies in the event sequence and outputs a spatio-temporal feature tensor, representing the temporal dynamics and potential associations between events in the entire order process.

[0130] Step 212: Based on the domain knowledge graph, construct a GNN graph encoding module, and extract the graph structure features through the graph encoding module;

[0131] In this embodiment, it specifically includes:

[0132] According to the functional topology network constructed in the domain knowledge graph, use the feature vectors of each node in the domain knowledge graph as the initial features of each node, and use the adjacency matrix and dynamic edge weight information to construct a graph data structure reflecting the interaction relationship between nodes;

[0133] Select a message passing mechanism such as a graph convolutional network, a graph attention network, or a hypergraph neural network to perform multi-layer information passing on each node in the graph structure and aggregate the neighborhood node features; it should be noted that an edge weight dynamic update strategy is introduced during the information passing process to ensure that non-linear and time-varying relationships can be captured;

[0134] Output the node feature matrix after multi-layer aggregation, and generate a global context representation for each node. This global context representation serves as the graph structure feature.

[0135] In the example of step 211, after step 212, a graph convolutional network or a graph attention network is used to transmit information between nodes. For example, if the "payment processing" node detects delay information, then through the graph structure, this information will be transmitted to the "inventory check" node, enabling the inventory check module to make preparations in advance; thus, finally, context-sensitive representations of each node are output, and these sensitive representations contain the local dependencies and business constraint information of each node in the entire order processing process.

[0136] Step 213: Fuse the spatio-temporal sequence features and the graph structure features, and generate fused features through a predefined induced signal loss function.

[0137] In this embodiment, it specifically includes:

[0138] Adopt the design of bilinear pooling, cross-attention mechanism or a fusion layer such as a fully connected network and a residual connection to align the spatio-temporal sequence features extracted by the Transformer with the graph structure features output by the GNN, and input the aligned spatio-temporal sequence features and graph structure features into the fusion layer.

[0139] In the fusion layer, through a predefined induced signal loss function (such as a constraint consistency loss, a smoothing regularization term), guide the feature representations generated by the model to meet the target constraints such as resource consumption time, response time, and anomaly detection during backpropagation, and these target constraints depend on the actual requirements of the project.

[0140] Output a unified cross-modal feature representation through the fusion layer as the fused feature; it can be understood that this representation contains both the global spatio-temporal dependencies of the Transformer and the local topological information of the GNN, and embeds the domain-induced signal constraint information, providing sufficient semantic expression for the generation of subsequent logic flow templates.

[0141] In the example of step 212, after step 213, fuse the global spatio-temporal features output by the Transformer (for example, the time dependencies and delay patterns of each event during the order processing process) with the graph structure features output by the GNN (for example, the states and dependencies of each process node), and predefined business rules, such as "trigger manual review if the payment delay exceeds 5 minutes" and "automatically switch to the replenishment process when the inventory is insufficient". These rules are reflected in that if a "payment delay" signal is detected, the system adds a "delay risk" component in the fusion layer, enabling the "payment exception handling" process to be reflected during subsequent template generation.

[0142] Step 214: Construct an executable logic flow template according to the fused feature.

[0143] In this embodiment, it specifically includes:

[0144] Construct a template generation module based on a Transformer decoder or a graph decoder, and use the fused feature representation after fusion as the input;

[0145] During the decoding process, embed the constraints from domain rules, such as resource limitations, response latency constraints, and exception handling rules for each process node, so that the generated template meets the actual business requirements;

[0146] Define a joint loss function including a generation loss such as cross-entropy loss, an induced signal constraint loss, and a domain consistency loss. According to the generation loss, train through a training sample set, and verify the generated template through offline simulation or small-scale online testing.

[0147] In the example of step 213, after step 214, during the decoding process, combine the previously injected induced signals (such as payment delay, inventory shortage risk) with the node transition rules to generate a specific business process template in the domain of this online retail business;

[0148] For example: Step 1: Order verification; including input: basic order information; inspection items: order legality, user credit; Step 2: Payment processing; input: payment request; rule: if the payment is delayed for more than 5 minutes, trigger the manual review branch; Step 3: Inventory check; input: payment confirmation information; rule: automatically check the inventory status, and call the replenishment process if the inventory is insufficient; Step 4: Logistics scheduling; input: inventory confirmation information; rule: allocate the nearest distribution center according to the order region and real-time traffic information;

[0149] Exception handling branch: Set predefined handling strategies for exceptions in each link, such as payment failure, inventory exception, etc.;

[0150] During the entire process of training through the training sample set, optimize the template generation process through the joint loss, so that the output template meets the optimization requirements in terms of resource consumption, response time, and exception detection;

[0151] It should be noted that the Transformer module can capture global spatio-temporal dependence information through the multi-head self-attention mechanism, while the GNN module focuses on local topological structure and relationship modeling between nodes. The fusion of the two enables the system to simultaneously process multiple data modalities such as text, time series, and graph structures, forming a unified high-dimensional feature representation. This cross-modal alignment ability not only improves the data representation ability and information richness, but also can embed fine semantic constraints in the logic flow template to ensure that the generated workflow meets the business rules and resource scheduling requirements, thus greatly reducing the complexity and error rate of developers' manual writing of low-code logic.

[0152] In an embodiment of the present invention, encoding the executable logic flow template into a Markov decision process includes the following steps:

[0153] Step 311: Preprocess the input executable logic flow template, extract the business processes, decision nodes, and transition conditions described therein, and construct the state space of the Markov decision process based on the extracted business processes, decision nodes, and transition conditions;

[0154] Specifically, a general logic flow template is presented in a structured data format, such as XML, JSON, or BPMN, etc., and defines nodes representing different links of business processes inside, such as order verification, payment processing, etc., as well as the transfer rules and constraint conditions between them. Therefore, normalize the nodes of each link into a state vector s, where s = [f1, f2,..., fi,..., fn], i = 1, 2, 3... n, and each feature fi represents a certain attribute of the node in the process, such as execution time, resource consumption, constraint conditions, etc. The state vectors of all nodes constitute the state space, and n is the number of all attributes.

[0155] Step 312: Identify the operation options allowed for each decision node from the parsed template to form the action space of the Markov decision process;

[0156] Specifically, an executable logic flow template usually attaches different decision or transfer options to each state node, and these options correspond to the actions that the system can take in a certain state in the MDP model. For any state s, define an action set A(s), and each of its elements a represents a decision choice or operation method. For example, at a certain node, one may choose "continue execution", "skip", or "turn to exception handling", etc.; the action sets of all states s constitute the action space.

[0157] Step 313: Formalize the process transfer relationship described in the logic flow template into the state transition function of the Markov decision process;

[0158] Specifically, represent the state transition function as P1(s′∣s,a), where P1 represents the probability that state s transfers to state s′. If some transfers in the template are deterministic, such as "if condition x is satisfied, then it will definitely enter state s1", then P1(s1|s,a) can be set to 1; for transfers with stronger uncertainty, appropriate probability values are assigned to different states according to historical data or prior statistics.

[0159] Step 314: Design a reward function for the Markov decision process to evaluate the immediate gain or cost obtained after taking action a in state s;

[0160] Specifically, the reward function is represented as R(s,a), which represents the numerical reward generated by executing action a in state s;

[0161] The specific form of the reward function is determined according to the actual business requirements. For example, if a certain decision can effectively reduce the execution time or resource occupancy, a positive reward should be given; on the contrary, if it may cause delays, resource waste, or process anomalies, it is set as a negative reward, so as to reflect the comprehensive impact of each decision choice in the entire logic flow template on the business goal through the reward function, so that the model can automatically tend to the optimal decision path during policy optimization.

[0162] Step 315: The state space, action space, state transition function, and reward function constitute a Markov decision process.

[0163] In the embodiments of the present invention, the joint policy optimization of the optimization objectives of the logic flow of the Markov decision process by the feature importance index generated by the integrated gradient backpropagation path and the multi-objective reinforcement learning framework of the Pareto front analysis module includes the following steps:

[0164] Step 321: Take the logic flow that has been encoded as a Markov decision process as the optimization object, and use the integrated gradient method to calculate the feature importance of the backpropagation path;

[0165] Specifically, the feature importance of the backpropagation path refers to the contribution degree of each path or each node to the overall goal, such as resource consumption, response time, exception handling quality, etc.;

[0166] The function expression of the integrated gradient method is:

[0167]

[0168] where s i is the i-th component of the state vector s, α is the normalized interpolation factor, and the feature importance index I = [IG1, IG2,..., IG i ,…, IG n is obtained, where each parameter IG i corresponds to the importance of the i-th feature, reflecting the influence of each node or path in the logic flow on the overall optimization goal;

[0169] Step 322: Design a Pareto front analysis module, construct a multi-objective evaluation system for the domain project, and generate an objective function with weights for each objective based on the feature importance;

[0170] Specifically, since the optimization objectives of the logic flow usually involve multiple dimensions, such as minimizing resource consumption, shortening response time, and reducing the incidence of exceptions, these objectives often restrict each other and cannot be optimally solved simultaneously through a single objective function. Therefore, it is necessary to introduce a Pareto front analysis module to construct a multi-objective evaluation system. The Pareto front is defined as the set of strategies in all strategy sets where there is no other strategy that can improve at least one objective while keeping other objectives unchanged or improved.

[0171] First, set multiple objective functions {J1, J2, …, Jk, …, JK}, where k = 1, 2, 3 … K and K is the number of all objectives. Each objective function corresponds to an optimization objective. For example, J1 reflects the resource consumption index of the system, J2 reflects the response time or throughput rate, and J3 reflects exception handling and error rate.

[0172] Take the feature importance index I of each objective obtained by the integrated gradient method as the weight factor and assign weights to each objective function. For example, any objective function Jk can become ∑ k g(Ik) × Jk after being assigned weights, where g(Ik) is obtained by mapping the kth normalized feature importance by the mapping function g.

[0173] For each candidate strategy π of each decision path in the logic flow, obtain the corresponding objective vector J(π) = [J1(π), J2(π), …, JK(π)]. Each vector value in the objective vector represents the value of an optimization objective.

[0174] By comparing the objective vectors of the candidate strategies, select the set of non-dominated strategies P. Specifically, the generation strategy of the set of non-dominated strategies P is

[0175] Step 323: Construct a multi-objective reinforcement learning framework that integrates the Markov decision process and the multi-objective evaluation system.

[0176] Specifically, construct the state space, action space, and multi-objective reward function described in the aforementioned Markov decision process into a multi-objective value function, Q(s, a) = [Q1(s, a), Q2(s, a), …, QKs,a)], where each component Qk(s, a) corresponds to the expected cumulative return of an objective function Ji among multiple objective functions.

[0177] By considering all objective functions simultaneously during the exploration and exploitation processes through the Q-learning algorithm, the overall optimum is achieved by updating the policy π(s). After each training cycle of the Q-learning algorithm, feedback from the Pareto front module is used to compare the currently generated policy with the set of non-dominated policies P, adjusting the exploration direction to ensure that the updated policy converges to the Pareto front in the multi-objective space;

[0178] Step 324: By defining a multi-objective loss function, joint policy optimization is performed according to the output of the multi-objective reinforcement learning framework;

[0179] Specifically, joint policy optimization refers to, after comprehensively considering various optimization objectives (such as resource consumption time, response time, exception handling, etc.), adopting a unified policy update method so that each decision node in the logic flow obtains a globally optimal decision;

[0180] Pre-define a multi-objective loss function L(π) = ∑ k λk × Lk(π), where Lk(π) respectively represents the loss for the objective Jk(π), the weight λk is the weighted sum of the feature importance of the objective Jk(π), and the policy update adopts the gradient descent method, calculating the gradient through backpropagation and updating the policy parameters;

[0181] It should be noted that through the combination of the feature importance index generated by integrating the gradient backpropagation path and the Pareto front analysis module, the multi-objective reinforcement learning framework can not only accurately capture the influence of key decision points during policy update but also seek the global optimal solution under multiple conflicting optimization objectives, thereby realizing the joint policy optimization of the logic flow.

[0182] In the embodiment of the present invention, the method of extracting the policy parameterized sequence after the joint policy optimization and injecting it into the dynamic verification sandbox environment constructed by the runtime monitoring module is as follows:

[0183] Mark the policy parameter sequence corresponding to the joint policy optimization as [θ1, θ2,..., θm,..., θM], m = 1, 2,..., M, where M is the number of nodes; each parameter θm represents the parameter set of the policy parameters of the corresponding decision node, and this policy parameter sequence is used as the policy parameterized sequence, and each policy parameter corresponds to an action in the action space of the Markov decision process;

[0184] Use containerization and virtualization technologies to construct a dynamic verification sandbox environment, simulate the code running conditions consistent with the production environment, and at the same time collect system behavior data through real-time monitoring tools; specifically, the system behavior data includes indicators such as response time, resource utilization rate, error rate, etc.;

[0185] Inject the policy parameterized sequence into the dynamic verification sandbox environment using standard interface calls and data mapping mechanisms to achieve online verification and feedback of the policy in real business scenarios;

[0186] Specifically, inject the policy parameterized sequence into the policy update module in the dynamic verification sandbox environment through predefined APIs. This module is responsible for applying the parameters to each decision node in the current sandbox environment. After injection, the dynamic verification sandbox environment starts to execute the dynamic verification task. During one or more test cycles, evaluate the actual effect of the new policy by simulating business requests and load scenarios. The monitoring module in the dynamic verification sandbox environment collects execution data in real time and calculates key metrics such as cumulative reward, latency change, and anomaly trigger rate, etc. The generated feedback information is returned to the decision engine in the form of vectors or matrices and further participates in the optimization loop of subsequent online policy adjustment;

[0187] In the embodiments of the present invention, the method for anomaly pattern detection and feedback-based parameter distillation of the execution trajectory through an online variational autoencoder is as follows:

[0188] Pre-collect the execution trajectory data of the policy execution in the dynamic verification sandbox environment and represent it as a set of trajectory sequences;

[0189] Specifically, the set of trajectory sequences can be represented as: T = {(s1, a1, r1), (s2, a2, r2),..., (sn, an, rn)};

[0190] The online variational autoencoder includes an encoder and a decoder, and its training objective is to maximize the evidence lower bound;

[0191] In the dynamic verification sandbox environment, use the online variational autoencoder to reconstruct the real-time collected execution trajectory and calculate the reconstruction error. Based on the reconstruction error, determine whether feedback-based parameter distillation is required;

[0192] For the execution paths that require feedback-based parameter distillation, collect the policy parameterized sequences of these execution paths, define a deviation loss function that quantifies the deviation between the current policy and the policy parameterized sequence, and use the gradient descent method to update the parameters of the deviation loss function;

[0193] During the process of this parameter update, the feedback information (i.e., anomaly metrics) directly participates in the construction of the loss function through a weighting mechanism, so that the parameters in the key anomaly regions are updated more significantly, that is, feedback-based parameter distillation is achieved. The updated parameterized sequence is re-injected into the logic flow, thereby adjusting the decision-making behavior in the dynamic verification sandbox environment and gradually reducing the probability of anomalies;

[0194] Specifically, the calculation method of the reconstruction error is: Among them, The execution trajectory reconstructed by the online variational autoencoder through the decoder;

[0195] It can be understood that under normal circumstances, due to the model being fully trained, the reconstruction error remains at a low level; while when the input trajectory shows abnormal patterns, such as unexpected delays, abnormal decisions, or error branches in the process, the reconstruction error will increase extremely rapidly. Therefore, an error threshold is set. When the reconstruction error is greater than this error threshold, it is determined that the execution trajectory is abnormal, and feedback-based parameter distillation is performed.

[0196] In an embodiment of the present invention, the method for automatically and elastically deploying the target service with the dynamically verified policy parameterized sequence is as follows:

[0197] The low-code platform receives the policy parameterized sequence obtained after online anomaly detection and feedback-based parameter distillation iteration, and converts each parameter into specific items of the deployment configuration through predefined mapping rules; such as the number of service instances, container image version, environment variables, and resource limits and request values, etc.;

[0198] Perform corresponding deployments on the low-code platform according to the obtained specific items of the deployment configuration.

[0199] As Figure 3 shown, the intelligent low-code development system optimized based on the deep learning model includes a knowledge graph construction module, a logic flow template construction module, a policy optimization module, a policy dynamic adjustment module, and a policy deployment module; among them, each module is connected electrically;

[0200] The knowledge graph construction module constructs a multi-dimensional domain knowledge graph through domain-driven meta-modeling technology and sends the domain knowledge graph to the logic flow template construction module;

[0201] The logic flow template construction module constructs a three-dimensional spatio-temporal fusion training sample set based on the domain knowledge graph, performs cross-modal feature alignment on the training sample set using a Transformer-GNN hybrid architecture, generates an executable logic flow template carrying semantic constraints, and sends the executable logic flow template to the policy optimization module;

[0202] The policy optimization module encodes the executable logic flow template into a Markov decision process, jointly optimizes the optimization objectives of the logic flow of the Markov decision process through the feature importance index generated by the integrated gradient backpropagation path and the multi-objective reinforcement learning framework of the Pareto front analysis module, and sends the policy parameterized sequence after joint policy optimization to the policy dynamic adjustment module;

[0203] The policy dynamic adjustment module extracts the parameterized sequence of the optimized combined policy, injects it into the dynamic verification sandbox environment constructed by the runtime monitoring module, and performs anomaly pattern detection and feedback-based parameter distillation iteration on the execution trajectory through an online variational autoencoder to complete the dynamic adjustment of the policy, and sends the dynamically adjusted policy to the policy deployment module;

[0204] The policy deployment module automatically and elastically deploys the parameterized sequence of the policy verified dynamically to the target service.

[0205] In addition, parts of the above technical solutions provided in the embodiments of the present application that are consistent with the implementation principles of the corresponding technical solutions in the prior art are not described in detail to avoid excessive elaboration.

[0206] As described in the specific embodiments above, the objectives, technical solutions, and beneficial effects of the present invention are further described in detail. It should be understood that the above are only specific embodiments of the present invention and are not used to limit the present invention. Any modifications, equivalent replacements, improvements, etc. made within the spirit and principles of the present invention shall be included in the protection scope of the present invention.

[0207] The above preset parameters or preset thresholds are all set by those skilled in the art according to the actual situation or obtained through a large amount of data simulation.

[0208] The above embodiments are only used to illustrate the technical method of the present invention and not to limit it. Although the present invention has been described in detail with reference to the preferred embodiments, those of ordinary skill in the art should understand that the technical method of the present invention can be modified or equivalently replaced without departing from the spirit and scope of the technical method of the present invention.

Claims

1. An intelligent low-code development method based on deep learning model optimization, characterized by: The following steps are involved: Step 1: Build a multi-dimensional domain knowledge graph through domain-driven meta-modeling technology; Step 2: Based on the domain knowledge graph, a three-dimensional spatiotemporal fusion training sample set is constructed, and the Transformer-GNN hybrid architecture is used to perform cross-modal feature alignment on the training sample set to generate an executable logic flow template with semantic constraints; Step 3: Encode the executable logic flow template into a Markov decision process, and perform joint strategy optimization on the optimization target of the logic flow of the Markov decision process by integrating the feature importance index generated by the gradient back-propagation path and the multi-objective reinforcement learning framework of the Pareto frontier analysis module; Step 4: extract the policy parameterization sequence after the joint policy optimization, inject it into the dynamic verification sandbox environment constructed by the runtime monitoring module, perform abnormal mode detection and feedback parameter distillation iteration on the execution trajectory through the online variational autoencoder, and complete the dynamic adjustment of the policy; Step 5: Automatically and flexibly deploy the target service using the dynamically verified policy parameterized sequence.

2. The intelligent low-code development method based on deep learning model optimization according to claim 1 is characterized in that: The method of constructing a multi-dimensional domain knowledge graph by domain-driven meta-modeling technology includes the following steps: Step 101: Define domain entity types, attributes, and relationship constraints through a visual metamodel editor, call a pre-trained multimodal alignment model to perform cross-modal semantic matching between structured database fields and unstructured document terms, generate an entity-attribute mapping table with confidence annotations, and realize alignment between domain metamodel definition and heterogeneous data; Step 102: Based on the entity-attribute mapping table, a domain-specific entity recognition model is trained using a joint learning framework, structured event triples are extracted from the business log, and entity interaction weights are calculated using a temporal decay function to construct a functional topological network with dynamic edge weights, thereby achieving dynamic entity relationship extraction and topological network construction; Step 103: parsing the business rules in the domain document, converting the atomic conditions in the business rules into a sparse constraint matrix aligned with the node feature dimension of the functional topology network, and eliminating rule conflicts through a self-attention mechanism; Step 104: Based on the IDs of each node in the functional topology network and the sparse constraint matrix, the business process log is sliced ​​in time and space, and the topological features and the time and space traffic patterns are integrated by using a hypergraph neural network to generate a low-rank compressed data flow tensor, thereby realizing the time and space representation learning of the data flow tensor; Step 105: Modally align the functional topological network, the sparse constraint matrix and the data flow tensor through the message passing mechanism of the graph neural network to generate a domain knowledge graph that integrates spatiotemporal-logical features and store it in a graph database.

3. The intelligent low-code development method based on deep learning model optimization according to claim 2 is characterized in that: Based on the domain knowledge graph, constructing a training sample set for three-dimensional spatiotemporal fusion includes the following steps: Step 201: Based on the adjacency matrix and node feature vectors of the functional topological network in the domain knowledge graph, a dynamic random walk algorithm is used to generate an entity interaction sequence; Step 202: Map the non-zero elements of the business rule constraint matrix to the space-time unit, and implement continuous space embedding of the rule features through sparse tensor multiplication; Step 203: construct a hierarchical graph attention network, which fuses multi-source features in three stages: bottom-level topological feature extraction, middle-level spatiotemporal feature fusion, and top-level rule feature injection; Step 204: Based on the spatiotemporal index and rule constraints of the domain knowledge graph, an adversarial generation strategy is used to construct difficult negative samples and generate a training sample set.

4. The intelligent low-code development method based on deep learning model optimization according to claim 3 is characterized in that: The method of using the Transformer-GNN hybrid architecture to perform cross-modal feature alignment on the training sample set and generate an executable logic flow template carrying semantic constraints includes the following steps: Step 211: Use the Transformer model to extract spatiotemporal sequence features from the training sample set; Step 212: Based on the domain knowledge graph, a GNN graph encoding module is constructed, and graph structure features are extracted through the graph encoding module; Step 213: Fusing the spatiotemporal sequence features and the graph structure features, and generating fusion features through a predefined induced signal loss function; Step 214: Based on the fused features, an executable logic flow template is constructed through a decoder.

5. The intelligent low-code development method based on deep learning model optimization according to claim 4 is characterized in that: The extraction of spatiotemporal sequence features comprises: The training sample set is constructed as a standard sequence input according to the time and space dimensions, and the position encoder is used to embed the position information of each element in the sequence to ensure that the Transformer can capture local and global spatiotemporal dependencies; A multi-head self-attention mechanism is used to extract features from the input sequence, and each attention head extracts global context information from different angles to provide multi-perspective spatiotemporal features; Several Transformer encoder layers are stacked, and the final output sequence feature tensor is used as the spatiotemporal sequence feature required for subsequent cross-modal fusion.

6. The intelligent low-code development method based on deep learning model optimization according to claim 4 is characterized in that: The extracting of graph structure features comprises: According to the functional topological network constructed in the domain knowledge graph, the feature vector of each node in the domain knowledge graph is used as the initial feature of each node, and the adjacency matrix and dynamic edge weight information are used to construct a graph data structure that reflects the interaction relationship between nodes; Use graph convolutional networks, graph attention networks, or hypergraph neural network message passing mechanisms to perform multi-layer information transmission on each node in the graph structure and aggregate the features of neighboring nodes; The node feature matrix after multi-layer aggregation is output, and a global context representation is generated for each node, which serves as a graph structure feature.

7. The intelligent low-code development method based on deep learning model optimization according to claim 4 is characterized in that: The generating fusion feature comprises: Adopt bilinear pooling, cross attention mechanism or the design of fusion layer such as fully connected network and residual connection to align the spatiotemporal sequence features extracted by Transformer with the graph structure features output by GNN, and input the aligned spatiotemporal sequence features and graph structure features into the fusion layer; In the fusion layer, the feature representation target constraint is guided by the model generated in the back propagation through the predefined induced signal loss function; The unified cross-modal feature representation is output through the fusion layer as the fusion feature.

8. The intelligent low-code development method based on deep learning model optimization according to claim 4 is characterized in that: The constructing of an executable logic flow template by a decoder includes: Construct a template generation module based on Transformer decoder or graph decoder, and take the fused feature representation as input; During the decoding process, constraints from domain rules are embedded, such as resource limits of each process node, response delay constraints, and exception handling rules, so that the generated template meets actual business needs; A joint loss function including the generation loss of cross entropy loss, the induced signal constraint loss and the domain consistency loss is defined. According to the generation loss, training is performed through the training sample set, and the generated template is verified through offline simulation or small-scale online testing.

9. The intelligent low-code development method based on deep learning model optimization according to claim 4 is characterized in that: The encoding of the executable logic flow template into a Markov decision process comprises the following steps: Step 311: pre-process the input executable logic flow template, extract the business process, decision nodes and transition conditions described therein, and construct the state space of the Markov decision process based on the extracted business process, decision nodes and transition conditions; Step 312: Identify the operation options allowed by each decision node from the parsed template to form an action space of the Markov decision process; Step 313: Formalize the process transition relationship described in the logic flow template into a state transition function of a Markov decision process; Step 314: Design a reward function for the Markov decision process to evaluate the immediate benefit or cost obtained after taking action a in state s; Step 315: The state space, action space, state transfer function and reward function constitute a Markov decision process.

10. The intelligent low-code development method based on deep learning model optimization according to claim 9 is characterized in that: The multi-objective reinforcement learning framework of integrating the feature importance index generated by the gradient back propagation path and the Pareto frontier analysis module to jointly optimize the optimization target of the logic flow of the Markov decision process includes the following steps: Step 321: taking the logic flow encoded as the Markov decision process as the optimization object, and using the integrated gradient method to calculate the feature importance of the back propagation path; Step 322: Design a Pareto frontier analysis module, construct a multi-objective evaluation system for the domain project, and generate a weighted objective function for each objective based on feature importance; Step 323: construct a multi-objective reinforcement learning framework integrating the Markov decision process and the multi-objective evaluation system; Step 324: By defining a multi-objective loss function, a joint strategy optimization is performed based on the output of the multi-objective reinforcement learning framework.

11. The intelligent low-code development method based on deep learning model optimization according to claim 10 is characterized in that: The method of extracting the policy parameterization sequence after the optimization of the joint policy and injecting it into the dynamic verification sandbox environment constructed by the runtime monitoring module is: Use containerization and virtualization technologies to build a dynamic verification sandbox environment to simulate code running conditions consistent with the production environment, and collect system behavior data through real-time monitoring tools; Adopt standard interface calls and data mapping mechanisms to inject policy parameterized sequences into the dynamic verification sandbox environment, and implement online verification and feedback of policies in real business scenarios. The method of performing abnormal mode detection and feedback parameter distillation iteration on the execution trajectory through the online variational autoencoder is as follows: Collect the execution trajectory data of the dynamic verification sandbox environment policy execution in advance and represent it as a trajectory sequence set; The online variational autoencoder consists of an encoder and a decoder, and its training objective is to maximize the evidence lower bound; In the dynamic verification sandbox environment, an online variational autoencoder is used to reconstruct the execution trajectory collected in real time and calculate the reconstruction error. Based on the reconstruction error, it is determined whether feedback parameter distillation is needed. For the execution path that requires feedback parameter distillation, the policy parameterization sequence of the execution path is collected, a deviation loss function that quantifies the deviation between the current policy and the policy parameterization sequence is defined, and the gradient descent method is used to update the parameters of the deviation loss function.

12. The intelligent low-code development method based on deep learning model optimization according to claim 11 is characterized in that: The method of automatically and elastically deploying the target service using the dynamically verified policy parameterized sequence is as follows: The low-code platform receives the policy parameterization sequence obtained after online anomaly detection and feedback parameter distillation iterations, and converts each parameter into a specific item of the deployment configuration through predefined mapping rules; Perform corresponding deployment on the low-code platform based on the specific items of the deployment configuration obtained.

13. An intelligent low-code development system based on deep learning model optimization, which is used to implement the intelligent low-code development method based on deep learning model optimization as described in any one of claims 1 to 12, characterized in that: It includes a knowledge graph construction module, a logic flow template construction module, a strategy optimization module, a strategy dynamic adjustment module and a strategy deployment module; wherein each module is electrically connected; The knowledge graph construction module builds a multi-dimensional domain knowledge graph through domain-driven meta-modeling technology, and sends the domain knowledge graph to the logic flow template construction module; A logic flow template construction module, based on the domain knowledge graph, constructs a three-dimensional spatiotemporal fusion training sample set, uses a Transformer-GNN hybrid architecture to perform cross-modal feature alignment on the training sample set, generates an executable logic flow template with semantic constraints, and sends the executable logic flow template to the strategy optimization module; A strategy optimization module encodes the executable logic flow template into a Markov decision process, performs joint strategy optimization on the optimization target of the logic flow of the Markov decision process by integrating the feature importance index generated by the gradient back-propagation path and the multi-objective reinforcement learning framework of the Pareto frontier analysis module, and sends the strategy parameterization sequence after the joint strategy optimization to the strategy dynamic adjustment module; The strategy dynamic adjustment module extracts the strategy parameterization sequence after the joint strategy optimization, injects it into the dynamic verification sandbox environment constructed by the runtime monitoring module, performs abnormal mode detection and feedback parameter distillation iteration on the execution trajectory through the online variational autoencoder, completes the dynamic adjustment of the strategy, and sends the dynamically adjusted strategy to the strategy deployment module; The policy deployment module automatically and flexibly deploys the target service using a dynamically verified policy parameterized sequence.

Images