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

Abstract

The application discloses an intelligent low-code development method and system based on a deep learning model optimization, relates to the technical field of deep learning, and through the construction of a multidimensional domain knowledge graph, based on the domain knowledge graph, a three-dimensional space-time fusion training sample set is constructed, cross-modal feature alignment is performed on the training sample set, an executable logic flow template is generated, and the executable logic flow template is coded into a Markov decision process, a feature importance index generated through an integrated gradient back propagation path is combined with a multi-objective reinforcement learning framework of a Pareto frontier analysis module, joint strategy optimization is performed on the optimization target of the logic flow, a strategy parameterization sequence after the joint strategy optimization is extracted, a dynamic verification sandbox environment is injected, abnormal mode detection and feedback type parameter distillation iteration are performed on an execution track through an online variational autoencoder, and dynamic adjustment of the strategy is completed, so that the elasticity, stability and expandability of the low-code platform are improved.

Description

Technical Field

[0001] This invention relates to the field of deep learning technology, specifically to an intelligent low-code development method and system based on deep learning model optimization. Background Technology

[0002] In modern low-code platforms, as business complexity increases, low-code platforms are gradually becoming a key tool for enterprise digital transformation. Low-code platforms simplify application development and deployment through graphical interfaces, enabling business personnel to participate in development and reducing development costs and time. However, with the increasing complexity of business scenarios and the rising demands for system performance, traditional low-code platforms face the challenge of maintaining flexibility and efficiency in constantly changing business needs and technological environments. Especially in critical areas 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 system's inability to efficiently adapt to business changes or quickly adjust in dynamic environments during large-scale deployments.

[0003] In existing technologies, low-code platforms typically rely on static rules or predefined decision models to deploy and execute logical flows. This approach often struggles to cope 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 adjust in real time according to dynamic factors such as business load and resource requirements. This often leads to performance bottlenecks or resource waste when the platform faces large-scale data and business fluctuations.

[0004] To this end, this invention proposes an intelligent low-code development method and system based on deep learning model optimization. Summary of the Invention

[0005] This invention aims to address at least one of the technical problems existing in the prior art. To this end, this invention proposes an intelligent low-code development method and system based on deep learning model optimization, which improves the elasticity, stability, and scalability of low-code platforms.

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

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

[0008] Step 2: Based on the domain knowledge graph, construct a three-dimensional spatiotemporal fusion training sample set, and use the 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 perform joint policy optimization on the optimization objective of the logic flow of the Markov decision process by integrating the feature importance index generated by the gradient backpropagation path with the multi-objective reinforcement learning framework of the Pareto front analysis module.

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

[0011] Step 5: Automated and elastically deploy the dynamically validated strategy parameterized sequence to the target service;

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

[0013] Step 101: Define domain entity types, attributes, and relational constraints through the visual metamodel editor, call the 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 labels, and realize the alignment of domain metamodel definition with heterogeneous data;

[0014] 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 business logs, and entity interaction weights are calculated using a time-series decay function. A functional topology network with dynamic edge weights is constructed to achieve dynamic entity relationship extraction and topology network construction.

[0015] 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 a self-attention mechanism;

[0016] Step 104: Based on the node IDs in the functional topology network and the sparse constraint matrix, the business process log is spatiotemporally sliced, and the topological features and spatiotemporal flow patterns are fused using a hypergraph neural network to generate a low-rank compressed data flow tensor, thereby realizing the spatiotemporal representation learning of the data flow tensor.

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

[0018] Based on the aforementioned domain knowledge graph, constructing a training sample set for 3D spatiotemporal 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, a dynamic random walk algorithm is used to generate entity interaction sequences;

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

[0021] Step 203: Construct a hierarchical graph attention network, which integrates multi-source features in three stages: bottom-level topological feature extraction, middle-level spatiotemporal feature fusion, and top-level rule feature injection;

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

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

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

[0025] The extraction of spatiotemporal sequence features includes:

[0026] The training sample set is constructed as a standard sequence input according to the time and space dimensions. 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.

[0027] A multi-head self-attention mechanism is used to extract features from the input sequence, and each attention head extracts global contextual information from different angles, providing multi-view spatiotemporal features;

[0028] Stack several Transformer encoder layers, and the final output sequence feature tensor serves as the spatiotemporal 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 extraction of graph structure features includes:

[0031] Based on the functional topology 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. The adjacency matrix and dynamic edge weight information are used to construct a graph data structure that reflects the interaction relationship between nodes.

[0032] Message passing mechanisms such as graph convolutional networks, graph attention networks, or hypergraph neural networks are selected 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 a dynamic edge weight update strategy is introduced during the information passing process to ensure that nonlinear and time-varying relationships can be captured.

[0033] The node feature matrix after multi-level aggregation is output, and a global context representation is generated for each node, which serves as the graph structure feature.

[0034] Step 213: Fuse the spatiotemporal sequence features and graph structure features, and generate fused features using a predefined induced signal loss function;

[0035] The generated fusion features include:

[0036] By employing bilinear pooling, cross-attention mechanisms, or a fusion layer design such as a fully connected network and residual connections, the spatiotemporal sequence features extracted by the Transformer are aligned with the graph structure features output by the GNN, and the aligned spatiotemporal sequence features and graph structure features are input into the fusion layer.

[0037] In the fusion layer, a predefined induced signal loss function guides the target constraints of the feature representation generated by the model during backpropagation;

[0038] The fusion layer outputs a unified cross-modal feature representation as the fusion feature;

[0039] Step 214: Based on the fusion features, construct an executable logic flow template using the decoder;

[0040] The step of constructing an executable logic flow template via a decoder includes:

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

[0042] During the decoding process, constraints from domain rules are embedded, such as resource limits, response latency constraints, and exception handling rules for each process node, so that the generated template meets the actual business requirements.

[0043] The definition includes a joint loss function such as cross-entropy loss, induced signal constraint loss, and domain consistency loss. Based on the generation loss, the template is trained using a training sample set and validated 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 process, decision nodes and transition conditions described inside it, and construct the state space of the Markov decision process based on the extracted business process, 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 flow transition relationships described in the logic flow template into state transition functions of a Markov decision process;

[0048] Step 314: Design a reward function for the Markov decision process to evaluate the immediate benefit or cost of taking action a in state s;

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

[0050] The multi-objective reinforcement learning framework, which integrates the feature importance index generated by the gradient backpropagation path with the Pareto front analysis module, performs joint policy optimization on the objective of the logistic flow optimization of the Markov decision process, including the following steps:

[0051] Step 321: Using the logic flow that has been encoded as a Markov decision process as the optimization object, the ensemble gradient method is used to calculate the feature importance of the backpropagation path;

[0052] Step 322: Design the Pareto frontier analysis module to construct a multi-objective evaluation system for domain projects, and generate objective functions with weights for each objective based on feature importance;

[0053] Step 323: Construct a multi-objective reinforcement learning framework that integrates Markov decision processes and multi-objective evaluation systems;

[0054] Step 324: Optimize the joint policy based on the output of the multi-objective reinforcement learning framework by defining a multi-objective loss function;

[0055] The method for extracting the optimized strategy parameter sequence from the joint strategy and injecting it into the dynamic verification sandbox environment constructed by the runtime monitoring module is as follows:

[0056] A dynamic verification sandbox environment is built using containerization and virtualization technologies to simulate code execution conditions consistent with the production environment, while system behavior data is collected through real-time monitoring tools.

[0057] The strategy parameterization sequence is injected into the dynamic verification sandbox environment using standard interface calls and data mapping mechanisms, enabling online verification and feedback of the strategy in real business scenarios.

[0058] The method of performing abnormal pattern detection and feedback parameter distillation iteration on the execution trajectory using an online variational autoencoder is as follows:

[0059] Execution trajectory data of the dynamic verification sandbox environment strategy execution is collected in advance and represented as a set of trajectory sequences;

[0060] An online variational autoencoder consists of an encoder and a decoder, and its training objective is to maximize the lower bound of evidence.

[0061] In a dynamic verification sandbox environment, an online variational autoencoder is used to reconstruct the execution trajectory acquired in real time and calculate the reconstruction error. Based on the reconstruction error, it is determined whether feedback parameter distillation is required.

[0062] For execution paths that require feedback parameter distillation, collect the policy parameterization sequence of the execution path, define the deviation loss function between the current policy and the policy parameterization sequence, and use the gradient descent method to update the parameters of the deviation loss function.

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

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

[0065] Deploy accordingly on the low-code platform based on the specific items of the obtained deployment configuration.

[0066] An intelligent low-code development system based on deep learning model optimization is proposed, including 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, the modules are connected to each other by electrical means.

[0067] The knowledge graph construction module constructs a multi-dimensional domain knowledge graph using 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 three-dimensional spatiotemporal 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.

[0069] The strategy optimization module encodes the executable logic flow template into a Markov decision process. By integrating the feature importance index generated by the gradient backpropagation path with the multi-objective reinforcement learning framework of the Pareto front analysis module, it performs joint strategy optimization on the optimization objective of the logic flow of the Markov decision process and sends the jointly optimized strategy parameterized sequence to the strategy dynamic adjustment module.

[0070] The strategy dynamic adjustment module extracts the parameterized sequence of the optimized joint strategy, 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 an online variational autoencoder, completes the dynamic adjustment of the strategy, and sends the dynamically adjusted strategy to the strategy deployment module.

[0071] The strategy deployment module automatically and elastically deploys dynamically validated strategy parameterized sequences to target services.

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

[0073] This invention first constructs a multi-dimensional knowledge graph using domain-driven modeling technology to extract key nodes and relationships in business processes. Then, it utilizes a Transformer-GNN hybrid architecture to align features of multimodal data, generating executable logic flow templates with semantic constraints. By integrating gradient and Pareto front analysis modules and combining them with a multi-objective reinforcement learning framework, it jointly optimizes the various objectives in the Markov decision process to find the optimal decision path. An online variational autoencoder performs real-time reconstruction of the execution trajectory and anomaly pattern detection. When deviations from the expected execution trajectory are detected, feedback is provided and a parameter distillation iteration process is triggered to automatically adjust the strategy, ensuring the stability and efficiency of the system in actual operation. Finally, the adjusted strategy is automatically deployed. This achieves real-time strategy optimization, flexible resource scheduling, avoids the static configuration problems of traditional methods, and improves the elasticity, stability, and scalability of the low-code platform. Attached Figure Description

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

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

[0076] Figure 3 This is a module connection diagram of the intelligent low-code development system based on deep learning model optimization in Embodiment 2 of the present invention. Detailed Implementation

[0077] The technical solution of the present invention will be clearly and completely described below with reference to the embodiments. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0078] In modern enterprise online service platforms, especially in areas such as large-scale online retail, logistics scheduling, and real-time data processing, the complexity of business processes and the dynamic changes in resource demands require platforms to possess high adaptability and flexibility. Existing technologies often fail to effectively predict and adjust resource allocation, leading to unstable system performance, particularly during peak business periods or when load fluctuations are significant. This can result in inefficient resource utilization, or even service interruptions or response delays. Therefore, achieving real-time strategy optimization and automated resource scheduling based on business data and operational status is a major technical challenge for enterprises.

[0079] Example 1

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

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

[0082] Step 2: Based on the domain knowledge graph, construct a three-dimensional spatiotemporal fusion training sample set, and use the 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 perform joint policy optimization on the optimization objective of the logic flow of the Markov decision process by integrating the feature importance index generated by the gradient backpropagation path with the multi-objective reinforcement learning framework of the Pareto front analysis module.

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

[0085] Step 5: Automated and elastically deploy the dynamically validated strategy parameterized sequence to the target service.

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

[0087] Step 101: Define domain entity types, attributes, and relational constraints through the visual metamodel editor, call the 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 labels, and realize the alignment of domain metamodel definition with heterogeneous data;

[0088] For example, the structured database fields and unstructured document terms input in step 101 can be schema metadata and API interface document description text in the domain database, while the output is a standardized set of semantic tags and a mapping table in JSON-LD format.

[0089] The multimodal alignment model uses a Bi-LSTM model to calculate the semantic similarity between 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. Unstructured documents (such as API interface documents) are TF-IDF weighted word vectorized and matched with a predefined ontology library using cosine similarity. Fields in the mapping table with confidence scores below a threshold (such as "txn_date" and "transaction date" having a similarity of 0.78, while the threshold is generally set to 0.8) are triggered for manual review, marked and corrected through a low-code platform.

[0090] 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 business logs, and entity interaction weights are calculated using a time-series decay function. A functional topology network with dynamic edge weights is constructed to achieve 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 aligned business logs, and the output is entity boundaries and type labels; while the temporal decay function is set as weight = original number of interactions × e. -0.1×ΔtΔt is the time difference between the current time and the most recent interaction corresponding to the event. Each event corresponds to an edge of the node. The weights of the outgoing edges of the same node are then normalized using 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 a self-attention mechanism;

[0093] For example, for the input contract terms text, CoreNLP is used to construct a dependency syntax tree and match predefined rule templates. For example, the atomic condition "Daily transfer amount > 50,000 requires review" is encoded into a sparse vector, where: condition dimension: the index position of the "transfer amount" node in the corresponding topology network is set to 1; threshold dimension: the 50,000th threshold position is set to -1; conflict resolution: the similarity between rules is calculated through a self-attention mechanism. If the similarity is > 0.7 and they are logically mutually exclusive, the rule with higher priority is retained. 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, the business process log is spatiotemporally sliced, and the topological features and spatiotemporal flow patterns are fused using a hypergraph neural network to generate a low-rank compressed data flow tensor, thereby realizing the spatiotemporal representation learning of the data flow tensor.

[0095] For example, the spatiotemporal slice dynamically adjusts the window length according to the peak period of business in the domain to generate several spatiotemporal units. Each spatiotemporal unit contains a quadruple of {source node ID, target node ID, time slice number, and traffic value}.

[0096] The training of the hypergraph neural network involves forming hyperedges by the nodes corresponding to the non-zero elements in the sparse constraint matrix (e.g., if rule R1 involves nodes N1 / N2 / N3, then hyperedge E1 is generated), and a gating mechanism is used to design GRU units to control the retention rate of historical traffic features.

[0097] Finally, the tensor compression described above 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 spatiotemporal tensor (source node × target node × time slice × feature channel), as follows: Figure 2 An example diagram of tensor transformation in Tucker decomposition is shown;

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

[0099] For example, a message-passing mechanism for defining a cross-modal aggregation function in a graph neural network can be used to achieve modality alignment. The form of the cross-modal aggregation function is as follows: Where N(i) is the set of neighboring nodes of the i-th node. and Let T represent the feature vectors of node i and its neighbor node j at the l-th layer, respectively. ij The spatiotemporal interaction features between nodes i and j originate from the spatiotemporal tensor compression result generated in step 104. For example, they include dynamic information such as traffic patterns (e.g., transaction frequency) and resource consumption trends within the time slice, with dimensions aligned with node features, thus injecting spatiotemporal features into each node; α ij is the attention weight coefficient, which is dynamically calculated through the attention mechanism to reflect the importance of neighbor node j to the current node i; W is the trainable weight matrix, which is used to perform linear transformation on the concatenated multimodal features to extract the implicit associations across modalities; || 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 spatiotemporal features generated in step 104.

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

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

[0102] In this embodiment, it specifically includes:

[0103] Based on the time-slicing rules of the data flow tensor (e.g., 5 minutes per time unit), the business log stream is divided into continuous spatiotemporal units. Each unit contains a source node ID, a target node ID, a timestamp, and interaction attributes (e.g., transaction amount, response latency). During this process, the business attributes embedded in the node feature vectors (e.g., "account risk level" in financial scenarios) are transformed into weight adjustment factors for the walk path, ensuring that the frequency of high-risk entities appearing in the sampling sequence increases by 40%-60%. For example, in an anti-money laundering scenario, a weight gain coefficient of 1.5 is applied to account nodes marked as "high-risk," significantly increasing the coverage of related transaction events in the training samples.

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

[0105] In this embodiment, it specifically includes:

[0106] For each source and target node in a spatiotemporal unit, the corresponding row and column vectors of the business rule constraint matrix are retrieved, and the Hadamard Product operation is performed to generate a 32-dimensional rule feature vector. During this process, the orthogonality constraint between the feature dimensions of the topological network nodes and the rule matrix (such as the correlation between the "daily transfer limit" rule and the "account type" feature in the financial field) is utilized to automatically filter out superimposed interference from conflicting rules in the same spatiotemporal unit. For example, when it is detected that a spatiotemporal unit simultaneously triggers both the "cross-border transfer requires review" and "VIP customer review waiver" rules, the system selects to retain the higher-priority rule feature based on the rule priority parameter (predefined in the domain knowledge graph).

[0107] Step 203: Construct a hierarchical graph attention network, which integrates multi-source features in three stages: bottom-level topological feature extraction, middle-level spatiotemporal feature fusion, and top-level rule feature injection;

[0108] In this embodiment, it specifically includes:

[0109] The underlying topology feature extraction includes: based on the entity interaction sequence generated in step 201, aggregating the attribute features of neighboring nodes (such as "user credit score" and "device geographical location") through GAT, and outputting the topology embedding vector;

[0110] The mid-level spatiotemporal feature fusion includes: concatenating the data flow patterns, such as the number of transactions per second, corresponding to the time slice in the tensor with the topological embedding vector, and extracting temporal dependency features using a temporal convolutional network (TCN);

[0111] Top-level rule feature injection includes gating attention fusion of the rule feature vector generated in step 202 with spatiotemporal features and dynamically adjusting the contribution weights of each modality.

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

[0113] In this embodiment, specifically including but not limited to:

[0114] In a functional topology network, node pairs that are similar in degree centrality (difference < 0.1) to the positive sample source node but have no direct connection are selected to achieve topology similarity sampling.

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

[0116] The sparse encoding result of the business rule constraint matrix is ​​used to perform logical conflict detection on the generated candidate negative samples. If a sample triggers a rule conflict flag (e.g., "transfer amount exceeding limit" and "recipient blacklist coexisting"), it is retained as a high-value negative sample. In supply chain finance scenarios, this method improves the model's detection rate of the "fictitious trade background" fraud pattern by 28%, achieving rule conflict enhancement.

[0117] In a further embodiment of the present invention, a double-buffered storage and incremental computing mechanism can be established to achieve dynamic synchronization between the training sample set and the domain knowledge graph.

[0118] Specifically, this includes triggering incremental updates to the knowledge graph (such as fine-tuning of node feature vectors and changes to the sparse mode of the rule matrix) when new business logs flow in, and comparing the version hash value of the domain knowledge graph. This version hash value is jointly generated by the topological structure signature, the sparse mode of the rule matrix, and the tensor decomposition basis vectors to identify the affected spatiotemporal units and re-execute 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 and generate an executable logic flow template carrying semantic constraints includes the following steps:

[0120] Step 211: Use the Transformer model to extract spatiotemporal sequence features from the training sample set;

[0121] In this embodiment, it specifically includes:

[0122] The training sample set is constructed as a standard sequence input according to the time and space dimensions. 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.

[0123] A multi-head self-attention mechanism is used to extract features from the input sequence, and each attention head extracts global contextual information from different angles, providing multi-view spatiotemporal features;

[0124] Several Transformer encoder layers are stacked, and the final output sequence feature tensor serves as the spatiotemporal sequence features required for subsequent cross-modal fusion.

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

[0126] Given a domain knowledge graph, each node in the graph represents a key step in order processing: order verification, payment processing, inventory check, logistics scheduling, and exception handling. Edges describe the dependencies between these steps, such as "order verification" must be completed before "payment processing".

[0127] Using normalized order time-series data, events such as "order placement", "payment confirmation", "inventory check" and "logistics scheduling" are arranged in chronological order, and a timestamp and spatial location are embedded in each event;

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

[0129] The multi-layer Transformer encoder gradually extracts the global spatiotemporal dependencies in the event sequence and outputs a spatiotemporal feature tensor that represents the temporal dynamics and potential correlations between events in the entire order process.

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

[0131] In this embodiment, it specifically includes:

[0132] Based on the functional topology 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. The adjacency matrix and dynamic edge weight information are used to construct a graph data structure that reflects the interaction relationship between nodes.

[0133] Message passing mechanisms such as graph convolutional networks, graph attention networks, or hypergraph neural networks are selected 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 a dynamic edge weight update strategy is introduced during the information passing process to ensure that nonlinear and time-varying relationships can be captured.

[0134] The node feature matrix after multi-level aggregation is output, and a global context representation is generated for each node, which serves as the graph structure feature.

[0135] In the example of step 211, after step 212, a graph convolutional network or graph attention network is used to pass information between nodes. For example, if the "payment processing" node detects delay information, this information will be passed to the "inventory check" node through the graph structure, so that the inventory check module can make preparations in advance. Thus, the context-sensitive representations of each node are finally output. These sensitive representations contain the local dependencies and business constraints of each node in the entire order processing flow.

[0136] Step 213: Fuse the spatiotemporal sequence features and graph structure features, and generate fused features using a predefined induced signal loss function;

[0137] In this embodiment, it specifically includes:

[0138] By employing bilinear pooling, cross-attention mechanisms, or a fusion layer design such as a fully connected network and residual connections, the spatiotemporal sequence features extracted by the Transformer are aligned with the graph structure features output by the GNN, and the aligned spatiotemporal sequence features and graph structure features are input into the fusion layer.

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

[0140] The fusion layer outputs a unified cross-modal feature representation as the fusion feature. It can be understood that this representation contains both the global spatiotemporal dependency 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 subsequent generation of the logical flow template.

[0141] In the example of step 212, after step 213, the global spatiotemporal features output by Transformer (e.g., the time dependency and delay pattern of each event in the order processing process) are fused with the graph structure features output by GNN (e.g., the state and dependency relationship of each process node), and business rules are predefined, such as "triggering manual review if payment delay exceeds 5 minutes" and "automatically transferring to the replenishment process when inventory is insufficient". These rules are reflected in the fact that if a "payment delay" signal is detected, the system adds a "delay risk" component in the fusion layer, so that the "payment exception handling" process can be reflected when the subsequent template is generated.

[0142] Step 214: Based on the fusion features, construct an executable logic flow template using the decoder;

[0143] In this embodiment, it specifically includes:

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

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

[0146] The definition includes a joint loss function such as generation loss (e.g., cross-entropy loss), induced signal constraint loss, and domain consistency loss. Based on the generation loss, the template is trained using a training sample set, and the generated template is validated through offline simulation or small-scale online testing.

[0147] In the example of step 213, after step 214, during the decoding process, the previously injected inducement signals (such as payment delay, inventory shortage risk) are combined with the node transfer rules to generate a specific business process template in the field of online retail business.

[0148] For example: Step 1: Order Verification; Input: Basic order information; Check items: Order validity, user credit; Step 2: Payment Processing; Input: Payment request; Rule: If payment is delayed by more than 5 minutes, a manual review branch is triggered; Step 3: Inventory Check; Input: Payment confirmation information; Rule: Automatically check inventory status, and if inventory is insufficient, invoke the replenishment process; Step 4: Logistics Scheduling; Input: Inventory confirmation information; Rule: Allocate the nearest distribution center based on order location and real-time traffic information;

[0149] Exception handling branch: Set up predefined handling strategies for exceptions in each stage, such as payment failures and inventory abnormalities;

[0150] Throughout the training process using the training sample set, the template generation process is optimized through joint loss, so that the output template meets the optimization requirements in terms of resource consumption, response time, and anomaly detection.

[0151] It should be noted that the Transformer module can capture global spatiotemporal dependency information through a multi-head self-attention mechanism, while the GNN module focuses on modeling local topology and relationships between nodes. The fusion of the two enables the system to process multiple data modalities such as text, time series, and graph structures simultaneously, forming a unified high-dimensional feature representation. This cross-modal alignment capability not only improves the expressive power and information richness of the data, but also allows for the embedding of fine semantic constraints in the logic flow template, ensuring that the generated workflow meets business rules and resource scheduling requirements, thereby greatly reducing the complexity and error rate of developers manually writing 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 process, decision nodes and transition conditions described inside it, and construct the state space of the Markov decision process based on the extracted business process, decision nodes and transition conditions.

[0154] Specifically, general logic flow templates are presented in structured data formats such as XML, JSON, or BPMN. Internally, nodes representing different stages of the business process are defined, such as order verification and payment processing, as well as the transition rules and constraints between them. Therefore, the nodes of each stage are normalized into a state vector s, where s = [f1, f2, ..., fi, ..., fn], i = 1, 2, 3, ..., n. Each feature fi represents a certain attribute of the node in the process, such as execution time, resource consumption, and constraints. The state vectors of all nodes constitute the state space, and n is the number of all attributes.

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

[0156] Specifically, executable logic flow templates typically include different decision or transition options at each state node. These options correspond to the actions the system can take in a given state in the MDP model. For any state s, an action set A(s) is defined, where each element a represents a decision choice or operation, such as choosing "continue execution," "skip," or "transfer to exception handling" at a certain node. The action sets of all states s constitute the action space.

[0157] Step 313: Formalize the flow transition relationships described in the logic flow template into state transition functions of a Markov decision process;

[0158] Specifically, the state transition function is represented as P1(s′|s,a), where P1 represents the probability of transitioning from state s to state s′. If some transitions in the template are deterministic, such as "if condition x is satisfied, then state s1 will necessarily be entered", then P1(s1|s,a) = 1. For transitions with higher uncertainty, appropriate probability values ​​are assigned to different states based on historical data or prior statistics.

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

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

[0161] The specific form of the reward function is determined based on actual business needs. For example, if a decision can effectively reduce execution time or resource consumption, a positive reward should be given; conversely, if it may lead to delays, resource waste, or process abnormalities, a negative reward should be set. In this way, the reward function reflects the comprehensive impact of each decision choice in the entire logical flow template on the business objective, so that the model can automatically tend towards the optimal decision path when optimizing the strategy.

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

[0163] In an embodiment of the present invention, the joint policy optimization of the objective of the logistic flow of a Markov decision process using a multi-objective reinforcement learning framework that integrates the feature importance index generated by the gradient backpropagation path with the Pareto front analysis module includes the following steps:

[0164] Step 321: Using the logic flow that has been encoded as a Markov decision process as the optimization object, the ensemble gradient method is used to calculate the feature importance of the backpropagation path;

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

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

[0167]

[0168] Among them, s i Let be the i-th component of the state vector s, and α be the normalized interpolation factor, to obtain the feature importance index I = [IG1,IG2,…,IG...]. i ,…,IG n ], where each parameter IG i The importance of the i-th feature. Reflects the influence of each node or path in the logic flow on the overall optimization objective;

[0169] Step 322: Design the Pareto frontier analysis module to construct a multi-objective evaluation system for domain projects, and generate objective functions with weights for each objective based on feature importance;

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

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

[0172] The feature importance index I of each objective obtained by the ensemble gradient method is used as a weight factor to assign a corresponding weight to each objective function; for example, any objective function Jk can be transformed into ∑ after weighting. k g(Ik)×Jk, where g(Ik) is obtained by mapping the importance of the k-th feature after normalization using the mapping function g;

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

[0174] By comparing the target vectors of candidate strategies, a set of non-dominated strategies P is selected; specifically, the strategy for generating the set of non-dominated strategies P is...

[0175] Step 323: Construct a multi-objective reinforcement learning framework that integrates Markov decision processes and multi-objective evaluation systems;

[0176] Specifically, the state space, action space, and multi-objective reward function described in the aforementioned Markov decision process are constructed 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 reward of one of the multiple objective functions, Ji.

[0177] The Q-learning algorithm considers all objective functions simultaneously during the exploration and utilization process, and achieves overall optimality by updating the policy π(s). After each training cycle of the Q-learning algorithm, the Pareto front module provides feedback to compare the currently generated policy with the set of non-dominated policies P, adjust the exploration direction, and ensure that the updated policy converges to the Pareto front in the multi-objective space.

[0178] Step 324: Optimize the joint policy based on the output of the multi-objective reinforcement learning framework by defining a multi-objective loss function;

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

[0180] A multi-objective loss function L(π) = ∑ is defined in advance. k λk×Lk(π), where Lk(π) represents the loss for target Jk(π), and the weight λk is the weighted sum of the feature importance of target Jk(π). The policy update adopts the gradient descent method, calculates the gradient through backpropagation, and updates the policy parameters.

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

[0182] In an embodiment of the present invention, the method of extracting the optimized strategy parameterization sequence of the joint strategy and injecting it into the dynamic verification sandbox environment constructed by the runtime monitoring module is as follows:

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

[0184] A dynamic verification sandbox environment is constructed using containerization and virtualization technologies to simulate code execution conditions consistent with the production environment, while system behavior data is collected through real-time monitoring tools; specifically, the system behavior data includes indicators such as response time, resource utilization, and error rate;

[0185] The strategy parameterization sequence is injected into the dynamic verification sandbox environment using standard interface calls and data mapping mechanisms, enabling online verification and feedback of the strategy in real business scenarios.

[0186] Specifically, a predefined API is used to inject a parameterized sequence of strategies into the strategy update module of the dynamic verification sandbox environment. This module is responsible for applying the parameters to various decision nodes in the current sandbox environment. After injection, the dynamic verification sandbox environment begins to execute dynamic verification tasks. Within one or more test cycles, the actual effect of the new strategy is evaluated 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 indicators such as cumulative rewards, latency changes, and anomaly trigger rates. The generated feedback information is returned to the decision engine in vector or matrix form and further participates in the optimization cycle of subsequent online strategy adjustments.

[0187] In an embodiment of the present invention, the method of performing abnormal pattern detection and feedback parameter distillation iteration on the execution trajectory using an online variational autoencoder is as follows:

[0188] Execution trajectory data of the dynamic verification sandbox environment strategy execution is collected in advance and represented 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] An online variational autoencoder consists of an encoder and a decoder, and its training objective is to maximize the lower bound of evidence.

[0191] In a dynamic verification sandbox environment, an online variational autoencoder is used to reconstruct the execution trajectory acquired in real time and calculate the reconstruction error. Based on the reconstruction error, it is determined whether feedback parameter distillation is required.

[0192] For execution paths that require feedback parameter distillation, collect the policy parameterization sequence of the execution path, define the deviation loss function between the current policy and the policy parameterization sequence, and use the gradient descent method to update the parameters of the deviation loss function.

[0193] During the parameter update process, feedback information (i.e., anomaly indicators) directly participates in the construction of the loss function through a weighting mechanism, resulting in a more significant update of parameters in key anomaly regions, thus achieving feedback parameter distillation. The updated parameterized sequence is then reinjected 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 reconstruction error is calculated as follows: in, The execution trajectory reconstructed by the decoder from an online variational autoencoder;

[0195] Under normal circumstances, the reconstruction error remains at a low level because the model has been trained sufficiently. However, when the input trajectory exhibits abnormal patterns, such as unexpected delays, abnormal decisions, or erroneous branches in the process, the reconstruction error will rise rapidly. Therefore, an error threshold is set. When the reconstruction error exceeds this threshold, the execution trajectory is determined to be abnormal, and feedback parameter distillation is performed.

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

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

[0198] Deploy accordingly on the low-code platform based on the specific items of the obtained deployment configuration.

[0199] like Figure 3 As shown, the intelligent low-code development system based on deep learning model optimization 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, the modules are connected to each other electrically.

[0200] The knowledge graph construction module constructs a multi-dimensional domain knowledge graph using 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 spatiotemporal 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 strategy optimization module encodes the executable logic flow template into a Markov decision process. By integrating the feature importance index generated by the gradient backpropagation path with the multi-objective reinforcement learning framework of the Pareto front analysis module, it performs joint strategy optimization on the optimization objective of the logic flow of the Markov decision process and sends the jointly optimized strategy parameterized sequence to the strategy dynamic adjustment module.

[0203] The strategy dynamic adjustment module extracts the parameterized sequence of the optimized joint strategy, 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 an online variational autoencoder, completes the dynamic adjustment of the strategy, and sends the dynamically adjusted strategy to the strategy deployment module.

[0204] The strategy deployment module automatically and elastically deploys dynamically validated strategy parameterized sequences to target services.

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

[0206] The specific embodiments described above further illustrate the purpose, technical solution, and beneficial effects of the present invention. It should be understood that the above descriptions are merely specific embodiments of the present invention and are not intended to limit the invention. Any modifications, equivalent substitutions, or improvements made within the spirit and principles of the present invention should be included within the scope of protection of the present invention.

[0207] The preset parameters or preset thresholds mentioned above are all set by those skilled in the art based on actual conditions or obtained through large-scale data simulation.

[0208] The above embodiments are only used to illustrate the technical methods of the present invention and are not intended to limit it. Although the present invention has been described in detail with reference to preferred embodiments, those skilled in the art should understand that modifications or equivalent substitutions can be made to the technical methods of the present invention without departing from the spirit and scope of the technical methods of the present invention.

Claims

1. An intelligent low-code development method based on deep learning model optimization, characterized in that, Includes the following steps: Step 1: Construct a multi-dimensional domain knowledge graph using domain-driven meta-modeling techniques; Step 2: Based on the domain knowledge graph, construct a three-dimensional spatiotemporal fusion training sample set, and use the 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; Step 3: Encode the executable logic flow template into a Markov decision process, and perform joint policy optimization on the optimization objective of the logic flow of the Markov decision process by integrating the feature importance index generated by the gradient backpropagation path with the multi-objective reinforcement learning framework of the Pareto front analysis module. Step 4: Extract the optimized strategy parameterized sequence of the joint strategy, inject it into the dynamic verification sandbox environment constructed by the runtime monitoring module, and perform abnormal mode detection and feedback parameter distillation iteration on the execution trajectory through an online variational autoencoder to complete the dynamic adjustment of the strategy; Step 5: Automated and elastically deploy the dynamically validated strategy parameterized sequence to the target service.

2. The intelligent low-code development method based on deep learning model optimization according to claim 1, characterized in that, The construction of a multi-dimensional domain knowledge graph using domain-driven meta-modeling technology includes the following steps: Step 101: Define domain entity types, attributes, and relational constraints through the visual metamodel editor, call the 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 labels, and realize the alignment of domain metamodel definition with 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 business logs, and entity interaction weights are calculated using a time-series decay function. A functional topology network with dynamic edge weights is constructed to achieve dynamic entity relationship extraction and topology network construction. 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 a self-attention mechanism; Step 104: Based on the node IDs in the functional topology network and the sparse constraint matrix, the business process log is spatiotemporally sliced, and the topological features and spatiotemporal flow patterns are fused using a hypergraph neural network to generate a low-rank compressed data flow tensor, thereby realizing the spatiotemporal representation learning of the data flow tensor. Step 105: Align the functional topology network, the sparse constraint matrix, and the data flow tensor using the message passing mechanism of a 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, characterized in that, Based on the aforementioned domain knowledge graph, constructing a training sample set for 3D spatiotemporal fusion includes the following steps: Step 201: Based on the adjacency matrix and node feature vectors of the functional topology network in the domain knowledge graph, a dynamic random walk algorithm is used to generate entity interaction sequences; Step 202: Map the non-zero elements of the business rule constraint matrix to spatiotemporal units, and realize the continuous spatial embedding of rule features through sparse tensor multiplication; Step 203: Construct a hierarchical graph attention network, which integrates 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, construct difficult negative samples using an adversarial generation strategy to generate a training sample set.

4. The intelligent low-code development method based on deep learning model optimization according to claim 3, characterized in that, The step of using a Transformer-GNN hybrid architecture to perform cross-modal feature alignment on the training sample set and generate an executable logic flow template with 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, construct a GNN graph encoding module, and extract graph structure features through the graph encoding module; Step 213: Fuse the spatiotemporal sequence features and graph structure features, and generate fused features using a predefined induced signal loss function; Step 214: Based on the fusion features, construct an executable logic flow template using the decoder.

5. The intelligent low-code development method based on deep learning model optimization according to claim 4, characterized in that, The extraction of spatiotemporal sequence features includes: The training sample set is constructed as a standard sequence input according to the time and space dimensions. 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 contextual information from different angles, providing multi-view spatiotemporal features; Several Transformer encoder layers are stacked, and the final output sequence feature tensor serves as the spatiotemporal sequence features required for subsequent cross-modal fusion.

6. The intelligent low-code development method based on deep learning model optimization according to claim 4, characterized in that, The extraction of graph structure features includes: Based on the functional topology 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. The adjacency matrix and dynamic edge weight information are used to construct a graph data structure that reflects the interaction relationship between nodes. By using graph convolutional networks, graph attention networks, or hypergraph neural network message passing mechanisms, multi-layer information passing is performed on each node in the graph structure, and the features of neighboring nodes are aggregated. The node feature matrix after multi-level aggregation is output, and a global context representation is generated for each node, which serves as the graph structure feature.

7. The intelligent low-code development method based on deep learning model optimization according to claim 4, characterized in that, The generated fusion features include: By employing bilinear pooling, cross-attention mechanisms, or a fusion layer design such as a fully connected network and residual connections, the spatiotemporal sequence features extracted by the Transformer are aligned with the graph structure features output by the GNN, and the aligned spatiotemporal sequence features and graph structure features are input into the fusion layer. In the fusion layer, a predefined induced signal loss function guides the target constraints of the feature representation generated by the model during backpropagation; The fusion layer outputs a unified cross-modal feature representation as the fusion feature.

8. The intelligent low-code development method based on deep learning model optimization according to claim 4, characterized in that, The step of constructing an executable logic flow template via a decoder includes: Construct a template generation module based on a Transformer decoder or graph decoder, taking the fused feature representation as input; During the decoding process, constraints from domain rules are embedded, including resource limitations, response latency constraints, and exception handling rules for each process node, so that the generated template meets actual business needs. The definition includes a joint loss function comprising generation loss (including cross-entropy loss), induced signal constraint loss, and domain consistency loss. Based on the generation loss, the template is trained using a training sample set, and the generated template is validated 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, characterized in that, Encoding the executable logic flow template into a Markov decision process includes the following steps: Step 311: Preprocess the input executable logic flow template, extract the business process, decision nodes and transition conditions described inside it, 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 allowed operation options for each decision node from the parsed template to form the action space of the Markov decision process; Step 313: Formalize the flow transition relationships described in the logic flow template into state transition functions of a Markov decision process; Step 314: Design a reward function for the Markov decision process to evaluate the immediate benefit or cost of taking action a in state s; Step 315: The state space, action space, state transition function, and reward function constitute the Markov decision process.

10. The intelligent low-code development method based on deep learning model optimization according to claim 9, characterized in that, The multi-objective reinforcement learning framework, which integrates the feature importance index generated by the gradient backpropagation path with the Pareto front analysis module, performs joint policy optimization on the objective of the logistic flow optimization of the Markov decision process, including the following steps: Step 321: Using the logic flow that has been encoded as a Markov decision process as the optimization object, the ensemble gradient method is used to calculate the feature importance of the backpropagation path; Step 322: Design the Pareto frontier analysis module to construct a multi-objective evaluation system for domain projects, and generate objective functions with weights for each objective based on feature importance; Step 323: Construct a multi-objective reinforcement learning framework that integrates Markov decision processes and multi-objective evaluation systems; Step 324: Optimize the joint policy based on the output of the multi-objective reinforcement learning framework by defining a multi-objective loss function.

11. The intelligent low-code development method based on deep learning model optimization according to claim 10, characterized in that, The method for extracting the optimized strategy parameter sequence from the joint strategy and injecting it into the dynamic verification sandbox environment constructed by the runtime monitoring module is as follows: A dynamic verification sandbox environment is built using containerization and virtualization technologies to simulate code execution conditions consistent with the production environment, while system behavior data is collected through real-time monitoring tools. The strategy parameterization sequence is injected into the dynamic verification sandbox environment using standard interface calls and data mapping mechanisms, enabling online verification and feedback of the strategy in real business scenarios. The method of performing abnormal pattern detection and feedback parameter distillation iteration on the execution trajectory using an online variational autoencoder is as follows: Execution trajectory data of the dynamic verification sandbox environment strategy execution is collected in advance and represented as a set of trajectory sequences; An online variational autoencoder consists of an encoder and a decoder, and its training objective is to maximize the lower bound of evidence. In a dynamic verification sandbox environment, an online variational autoencoder is used to reconstruct the execution trajectory acquired in real time and calculate the reconstruction error. Based on the reconstruction error, it is determined whether feedback parameter distillation is required. For execution paths that require feedback parameter distillation, the policy parameterization sequence of the execution path is collected, a deviation loss function is defined to quantize the difference between the current policy and the policy parameterization sequence, and the deviation loss function is updated using the gradient descent method.

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

13. An intelligent low-code development system based on deep learning model optimization, used to implement the intelligent low-code development method based on deep learning model optimization as described in any one of claims 1-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; the modules are connected electrically. The knowledge graph construction module constructs a multi-dimensional domain knowledge graph using domain-driven meta-modeling technology and sends the domain knowledge graph to the logic flow template construction module. The logic flow template construction module constructs a three-dimensional spatiotemporal 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. The strategy optimization module encodes the executable logic flow template into a Markov decision process. By integrating the feature importance index generated by the gradient backpropagation path with the multi-objective reinforcement learning framework of the Pareto front analysis module, it performs joint strategy optimization on the optimization objective of the logic flow of the Markov decision process and sends the jointly optimized strategy parameterized sequence to the strategy dynamic adjustment module. The strategy dynamic adjustment module extracts the parameterized sequence of the optimized joint strategy, 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 an online variational autoencoder, completes the dynamic adjustment of the strategy, and sends the dynamically adjusted strategy to the strategy deployment module. The strategy deployment module automatically and elastically deploys dynamically validated strategy parameterized sequences to target services.

Images