An ai-based low-code assisted decision-making method and system

Abstract

The application provides an AI-based low-code assisted decision-making method and system, which comprises the following steps: collecting the event flow of a user on a low-code platform, constructing an event vector sequence and a behavior component mapping table; obtaining a low-code configuration graph to construct a behavior-structure fusion graph, generate a component complexity score table and determine a high complexity component set; according to the component complexity score table and the high complexity component set, construct a local causal subgraph, generate a path semantic nested matrix, generate a high-risk causal path set and give a path-level risk score, and generate a subgraph edge score matrix; taking the minimization of the consistency loss inside the path as the objective function, determining an optimization suggestion draft set and a suggestion positioning node set; mapping the optimization suggestion draft set and the suggestion positioning node set to the low-code configuration graph for visual labeling, automatically executing configuration modification after structure constraint verification, and recording change logs to support rollback and version tracing.

Description

Technical Field

[0001] The present invention belongs to the field of low-code, and in particular relates to an AI-based low-code decision-making assistance method and system. Background Art

[0002] Low-code development platforms have been widely adopted in enterprise digitalization scenarios in recent years, demonstrating significant advantages in improving development efficiency and lowering barriers to entry. Their defining feature is the visual component orchestration and parameterized configuration, enabling business personnel to quickly build systems such as approval processes, dynamic forms, and human resources management without requiring specialized programming knowledge. However, as business scenarios continue to evolve and requirements become more personalized, the configuration logic underlying low-code platforms has become increasingly complex, exposing their shortcomings in understanding structure and assessing risks during user operations. In practice, these platforms only provide static rule prompts and post-error feedback, making it difficult to identify the context behind operations and proactively identify hidden issues such as field logic conflicts, redundant process paths, and omitted jump conditions. Furthermore, existing platforms generally lack modeling and response mechanisms for behavioral signals such as repeated editing and drag-and-drop undo during operation. This results in a configuration process that relies heavily on user experience for manual troubleshooting and repair, resulting in inefficiency and the potential for missing critical risk points. Especially in scenarios where complex process forms are built in parallel and have a lot of nested logic, users often face problems such as confusing causal chains and structural dependency errors. The platform is unable to provide structural-level analysis or executable suggestions, which greatly limits the system's intelligent support capabilities in highly complex scenarios.

[0003] Therefore, how to establish a unified behavior-structure-semantic fusion modeling mechanism based on user configuration behavior, and improve the system's ability to identify highly complex areas, diagnose risk chains, generate and execute suggestions during the configuration stage, is a key issue that urgently needs to be broken through in the current evolution of low-code platforms. Summary of the Invention

[0004] The purpose of this invention is to propose an AI-based low-code decision-making assistance method and system. The system takes the collection of operation behavior as the starting point, combines configuration snapshots and resource status, constructs a behavior vector expression with semantic representation capabilities, and captures the user's continuous operation intentions under the sliding window.

[0005] In order to achieve the above objectives, a first aspect of the present invention provides an AI-based low-code decision-making assistance method, the method comprising:

[0006] S1. Collect the user's event stream on the low-code platform, including: operation behavior sequence, context state snapshot and system operation resource status, construct event vector sequence and behavior component mapping table, input the event vector sequence into the Transformer encoder, and perform average pooling to generate a behavior semantic vector set;

[0007] S2. Obtain the low-code configuration diagram to construct a behavior-structure fusion diagram, combine behavior aggregation and graph structure coupling to calculate the complexity score of each component, generate a component complexity score table and determine the high-complexity component set;

[0008] S3. Based on the component complexity score table and the high-complexity component set, the behavior semantic vector set and the behavior component mapping table are combined to construct a local causal subgraph in the low-code configuration diagram and generate a path semantic nesting matrix, and execute a depth limit of DFS traversal is performed to generate a set of high-risk causal paths and assign path-level risk scores, and a subgraph edge score matrix is ​​generated;

[0009] S4. Taking minimizing the consistency loss within the path as the objective function, for the set of high-risk causal paths, combined with the set of behavioral semantic vectors, determine a set of optimization suggestion drafts and a set of recommended positioning nodes;

[0010] S5. Map the optimization suggestion draft set and the recommended positioning node set to the low-code configuration diagram for visual annotation, automatically execute configuration modifications after structural constraint verification, and record change logs to support rollback and version tracing.

[0011] Furthermore, the S1 specifically includes:

[0012] S101. Obtaining event streams at the front end and back end of the low-code platform;

[0013] S102, dividing the event stream into time windows, wherein the event stream in each window constitutes an operation segment;

[0014] S103, performing an encoding process on all events of the operation fragment in each window to generate an event vector sequence and a behavior component mapping table;

[0015] S104: Input the event vector sequence into a set of Transformer encoders comprising a two-layer structure, perform average pooling on the output of the Transformer encoder, obtain a behavior semantic vector, and construct a behavior semantic vector set.

[0016] Furthermore, each behavior event in the operation behavior sequence is a five-tuple , indicating that the timestamp When the user For components The operation type is The action parameter is ;

[0017] The encoding process specifically includes:

[0018] Operation Type Mapped to a fixed-dimensional vector through 1-hot encoding, the components Then classify and map them according to the component family they belong to, and operate the parameters Different embedding strategies are adopted according to their formats.

[0019] Furthermore, the S2 specifically includes:

[0020] S201. Get the low-code configuration diagram , wherein Represents all component nodes in the page, Dependency edges are generated in real time by the platform rendering logic.

[0021] S202, according to the low-code configuration diagram Constructing a behavior-structure fusion diagram , where the nodes Contains low-code configuration diagrams The component nodes in the and each behavior semantic vector are used as virtual behavior nodes, and the edges Includes: component dependency edges of the low-code configuration graph; edges pointing from each behavior semantic vector node to its corresponding component; operation frequency edges;

[0022] S203. Calculate the complexity score of each component based on the behavior semantic vector, combined with behavior aggregation and graph structure coupling. , expressed as:

[0023] ;

[0024] Where i represents the i-th component; It represents the sum of all behavioral semantic vectors pointing to the component, and measures the behavioral activity of the component; It is a component In low-code configuration diagram The PageRank value in , which measures its structural centrality; It is a component The number of times it has been modified in the history log; is the rule conflict penalty term, when the component When there is a logical conflict in the bound validation rules, this item is 1, otherwise it is 0; These are weight coefficients, which are set to 0.3, 0.3, 0.2, and 0.2 in practice. The tuning process is based on feedback optimization of the actual form design complexity.

[0025] S204: Calculate and sort the complexity scores of all components, and select the component with the highest complexity score. components as high-complexity candidate sets and generate a component complexity score table.

[0026] Furthermore, if a component is modified multiple times in a historical sequence, a self-loop edge is introduced to enhance its activity.

[0027] Furthermore, the S3 specifically includes:

[0028] S301: Projecting the behavior semantic vector onto the component node according to the behavior component mapping table to form an aggregated behavior intention representation of each component, and aggregating the corresponding semantic vector of the aggregated behavior intention representation using a weighted average method;

[0029] S302. In the low-code configuration graph, edges are screened by designing a causal strength scoring function to construct a local causal subgraph; the subgraph edge scoring matrix is ​​obtained based on the causal strength scoring function;

[0030] S303: For the local causal subgraph, starting from each high-complexity component, execute a depth limit of The DFS traversal records all reachable paths and assigns a path risk score to each path. The path with the highest risk score indicates that the causal coupling between the components within the path is the tightest and the operation intention is the most consistent, thus forming a potential misconfiguration path or process stuck path.

[0031] Furthermore, the local causal subgraph has the following specific structure:

[0032] The nodes of the local causal subgraph are a subset of the low-code configuration graph nodes, specifically including:

[0033] First, all components belonging to the high-complexity component set are screened, and nodes with dependencies between the components belonging to the high-complexity component set within a 2-hop range are determined as nodes of the low-code configuration graph;

[0034] The edges of the local causal subgraph retain all edges that meet the causal strength score threshold edge pair; where the causal strength score Expressed as:

[0035] ;

[0036] in, is the standard cosine similarity function; is a structural conflict indicator function: if the node If there is a logical conflict in the component, , otherwise 0; is an adjustable coefficient.

[0037] Furthermore, the S4 specifically includes:

[0038] S401, performing semantic vector mapping on all nodes in each causal path in the high-risk causal path set, determining the semantic vector corresponding to the causal path, and forming a path semantic nesting matrix;

[0039] S402: Based on the semantic vectors of each pair of adjacent nodes on each causal path and in combination with the subgraph edge score matrix of each pair of adjacent nodes, a matrix is ​​generated to minimize the consistency loss within the path; and the consistency loss is higher than a set threshold. The paths are marked as structurally heterogeneous paths;

[0040] S403: determining, for the structurally heterogeneous path, a selection weight of the structurally heterogeneous path based on a subgraph edge score matrix corresponding to the structurally heterogeneous path and semantic uncertainty;

[0041] S404. Output all nodes that meet the selection weight greater than a preset threshold as candidate points for recommendation generation, and construct a set of optimization suggestion drafts. Each optimization suggestion draft in the set of optimization suggestion drafts represents a semantic vector, a configuration snapshot, and all adjacent nodes of the current node; the set of recommended positioning nodes is obtained based on the candidate points.

[0042] Furthermore, the S5 specifically includes:

[0043] S501. Map the draft optimization suggestion representations in the draft optimization suggestion set back to the corresponding nodes in the low-code configuration graph, quickly locate them through component ID index or timestamp mapping, and present them in a highlighted floating layer in the front-end graph structure; before executing the presentation, verify whether the change suggestion is legal under the current structure through the structural constraint relationship verification function between components;

[0044] S502. If the structural constraint relationship verification function between the components is 1, it is legal, and the structural update will be performed through the low-code configuration diagram of the back-end configuration management interface to form a new low-code configuration diagram, and the operation results will be written into the change log.

[0045] Another aspect of the present invention provides an AI-based low-code decision-making support system, the system comprising:

[0046] The user configures a behavior collection unit to collect the user's event stream on the low-code platform, including: operation behavior sequence, context state snapshot, and system operation resource status, construct an event vector sequence and behavior component mapping table, and input the event vector sequence into the Transformer encoder and perform average pooling to generate a behavior semantic vector set;

[0047] High-complexity area identification unit, used to obtain low-code configuration diagrams to construct behavior-structure fusion diagrams, combine behavior aggregation and graph structure coupling to calculate the complexity score of each component, generate a component complexity score table and identify high-complexity component sets;

[0048] A problem path identification unit is used to construct a local causal subgraph in the low-code configuration diagram based on the component complexity score table and the high-complexity component set, combined with the behavioral semantic vector set and the behavioral component mapping table, and generate a path semantic nesting matrix, and perform a depth limit of DFS traversal is performed to generate a set of high-risk causal paths and assign path-level risk scores, and a subgraph edge score matrix is ​​generated;

[0049] An optimization suggestion generating unit, configured to determine a set of optimization suggestion drafts and a set of recommended positioning nodes for the set of high-risk causal paths in combination with the set of behavioral semantic vectors, with minimization of the consistency loss within the path as the objective function;

[0050] A suggested visual presentation unit is used to map the optimization suggestion draft set and the suggested positioning node set to the low-code configuration diagram for visual annotation, automatically execute configuration modifications after structural constraint verification, and record change logs to support rollback and version tracing.

[0051] The beneficial technical effects of the present invention are at least as follows:

[0052] This paper addresses the complex, high-frequency, and logic-intensive configuration scenarios encountered in low-code development. It proposes a decision-making support method and system with contextual understanding, structural analysis, and intelligent intervention capabilities. Starting with operational behavior collection, the system combines configuration snapshots with resource status to construct a semantically expressive behavioral vector representation, capturing the user's continuous operational intent within a sliding window.

[0053] On this basis, by introducing the behavior-structure fusion graph, we can identify highly complex component areas in the page with dense structural dependencies, significant rule conflicts, and high operation frequency, and accurately determine the intervention targets through the component behavior semantic aggregation and structural centrality scoring mechanism.

[0054] Furthermore, the system constructs a causal subgraph in a highly complex area, and designs a path risk function based on the dual factors of semantic similarity and logical conflict. It automatically extracts potential problem paths and assigns path-level risk scores, achieving complete modeling and visual reasoning of the configuration error chain.

[0055] Based on the problem path, the system further designs a semantic consistency loss function and a suggestion location scoring function. This integrates semantic uncertainty with causal propagation capabilities to automatically locate structurally heterogeneous nodes and generate contextually interpretable structural optimization suggestions. Finally, the system maps the suggestions back to the original component graph for visualization and structural validity verification. If the suggestions comply with dependency constraints, automatic structural modifications are executed and logged for traceability and rollback.

[0056] Compared with existing methods that only prompt errors or perform static verification after configuration, the present invention realizes a complete closed-loop intelligent assistance process covering "behavior perception, complex area identification, causal path modeling, optimization suggestion generation and automatic execution", which significantly improves the system's ability to handle complex configuration tasks, and shows significant innovative value in improving configuration accuracy, reducing user burden, and supporting high-level process design. BRIEF DESCRIPTION OF THE DRAWINGS

[0057] The present invention is further described with reference to the accompanying drawings. However, the embodiments in the accompanying drawings do not constitute any limitation to the present invention. A person skilled in the art can obtain other drawings based on the following drawings without inventive effort.

[0058] Figure 1 This is a flow chart of an AI-based low-code decision-making assistance method according to an embodiment of the present invention.

[0059] Figure 2 This is a framework diagram of an AI-based low-code decision-making assistance system in an embodiment of the present invention. DETAILED DESCRIPTION

[0060] The following describes embodiments of the present invention in detail. Examples of the embodiments are shown in the accompanying drawings, wherein the same or similar reference numerals throughout represent the same or similar elements or elements having the same or similar functions. The embodiments described below with reference to the accompanying drawings are exemplary and are intended only to explain the present invention and are not to be construed as limiting the present invention.

[0061] like Figure 1 As shown, an embodiment of the present invention provides an AI-based low-code decision-making assistance method, the method comprising:

[0062] S1. Collect the user's event stream on the low-code platform, including: operation behavior sequence, context status snapshot and system operation resource status, build event vector sequence and behavior component mapping table, and input the event vector sequence into the Transformer encoder, and perform average pooling to generate a behavior semantic vector set.

[0063] Specifically, the goal of this step is to collect and model the configuration operations performed by low-code platform users in the interface in real time as context-aware semantic vector representations. This will be used in subsequent steps to identify configuration anomalies, complex logical areas, and generate intelligent assistance suggestions. Operational behaviors in the low-code development process manifest as high-frequency, highly semantically dependent event streams, such as dragging fields, filling in rules, and connecting nodes. These behaviors implicitly reflect the user's construction intentions, business process design ideas, and operational bottlenecks. If these behavioral characteristics can be expressed in a structured manner, it will lay a data foundation for the system's intelligent analysis.

[0064] The input in this step includes:

[0065] User operation behavior sequence , each behavioral event is a quintuple , indicating that the timestamp When the user For components The operation type is The action parameter is ;

[0066] Context state snapshot , which is a JSON snapshot of the form layout, process nodes, validation rules, field bindings, etc. on the current page;

[0067] System operation resource status , including front-end CPU usage and memory overhead, to analyze whether configuration repetitions are caused by performance bottlenecks;

[0068] Furthermore, the S1 specifically includes:

[0069] S101. Obtaining event streams at the front end and back end of the low-code platform;

[0070] Among them, this data is obtained through the collaborative efforts of two systems: the front-end uses event listeners (such as using v-on in the Vue framework to listen to user DOM events) to record events such as drag start, end, click, parameter input, etc. in real time; the back-end uses WebSocket or HTTP feedback interface to regularly collect the serialization results and running resource information of the current page DOM structure, and then package them into the system event cache after time alignment.

[0071] Collected event stream There are features such as sequential dependency, local repetition, and semantic ambiguity, so structured aggregation must be performed first and then converted into a learnable vector representation.

[0072] S102, dividing the event stream into time windows, wherein the event stream in each window constitutes an operation segment;

[0073] Specifically, the system divides the event stream into time windows. The default window length is 8 seconds, and a sliding window strategy is used, sliding forward every 3 seconds to ensure the integrity of high-frequency operations. The events in each window constitute an operation segment. For example, a window may contain a user dragging in the field "Budget Amount", then modifying the validation rules, and then connecting a process node. These continuous operations are an operation fragment.

[0074] S103: Execute an encoding process for all events of the operation fragment in each window to generate an event vector sequence and a behavior component mapping table, including:

[0075] Operation fragment All events in the code are executed. Mapped to a fixed-dimensional vector through 1-hot encoding, component type Classify and map them according to the component family (form, process, check, etc.) to which they belong, and the parameter value Different embedding strategies are used depending on the format (string, number, Boolean), for example:

[0076] For Boolean parameters (such as "is this field required"), they are directly mapped to 0 / 1;

[0077] Use learnable embedding for enumeration types (such as the value of the "approval status" field);

[0078] Performs logarithmic transformation on numeric values ​​(such as "field maximum").

[0079] These embedded features form a sequence of event vectors, which are then fed into a two-layer Transformer encoder. Each layer is configured with four attention heads, a hidden dimension of 128, and a dropout of 0.1. This attention mechanism models the temporal dependencies between events and the combination of operations.

[0080] S104, inputting the event vector sequence into a set of two-layer Transformer encoders, then performing average pooling on the output of the Transformer encoder to obtain a behavior semantic vector, and constructing a behavior semantic vector set, including: performing average pooling on each time step output of the Transformer output to obtain the overall behavior semantic vector of the operation segment . It can be formally expressed as:

[0081] ;

[0082] in, Indicates the embedding process of event sequence, including operation type , component type and parameter values Multi-channel encoding; Represents an encoder with a multi-head attention structure for learning dependencies between events; It means that the Transformer output sequence is average pooled in the time dimension to obtain a fixed-length representation.

[0083] For example, if a user performs the three steps of "add field A", "set field A as required", and "connect field A to process B" in a certain window, then the window will be encoded as a semantic vector, whose value will reflect the user's intention to set field A as a process-driving node in the current construction task, and there is an input verification requirement.

[0084] To ensure the consistency of subsequent modeling, all generated semantic vectors will perform unit scale normalization operations so that they have a uniform distribution range in the feature space.

[0085] Furthermore, the output of this step is: behavioral semantic representation set , indicating the operational semantics corresponding to each sliding window; behavioral component mapping table , where each row corresponds to a core component ID associated with a semantic vector, which is used for subsequent complex region identification.

[0086] S2. Obtain the low-code configuration diagram to build a behavior-structure fusion diagram, combine behavior aggregation and graph structure coupling to calculate the complexity score of each component, generate a component complexity score table and determine the high-complexity component set.

[0087] Specifically, this step aims to use the user behavior semantic vector extracted in step 1 and component mapping , automatically identifying "high-complexity areas" within low-code platform pages. In enterprise-level low-code applications, these high-complexity areas typically include component fragments with dense field dependencies, complex validation logic, high-frequency operations, and repeated modifications, such as multi-conditional jump nodes in approval processes and nested field groups in financial approval tables. These areas are prone to business errors and are the core areas that the intelligent decision-making module in this invention prioritizes for optimization.

[0088] This step is for each semantic vector generated in the previous stage , combined with the components it is bound to , constructing a joint behavior-structure graph and identifying potentially complex areas through feature fusion and scoring. This step's identification strategy doesn't rely on traditional component counting or form length estimation. Instead, it combines real user behavior characteristics, component structural dependencies, and historical modification paths to determine complexity using a semantic-driven and structurally coupled approach. This demonstrates the innovative integration of the present invention's "behavioral semantics + page structure + decision-making intelligence" trinity.

[0089] Among them, input: behavioral semantic representation set , output from step 1, represents the semantic vector of user operation behavior; behavior component mapping table , indicating the component ID corresponding to each behavior vector; low-code configuration diagram ,in Represents all component nodes in the page, Dependency edges between fields, fields, process nodes, and validation rules are generated in real time by the platform rendering logic; historical operation sequence , each Indicates time For components A configuration action is provided by the platform behavior tracking log.

[0090] Specific, low-code configuration diagram It is graph structure data generated by the platform by real-time parsing the component structure in the page each time the user operates on the page or saves the configuration. Specifically, the platform front-end will maintain a component tree during the page construction process to describe the hierarchy and relationship of all form fields, process nodes, validation rules and other components, and will synchronously update the component tree during the user operation process; at the same time, the back-end logic will automatically deduce the data dependency between fields (such as field A depends on the value of field B), process jump logic (such as the next step of node X depends on condition Y), and verification rule dependency (such as field F is bound to rule R) based on the component tree and parameter binding relationship, organize the above dependencies into E in the form of edges, and uniformly number all component nodes as a node set V of the graph structure, finally forming a complete low-code configuration graph G=(V,E). The graph structure is dynamically updated after each page rendering or component saving, and can be obtained in real time through the developer interface provided by the platform.

[0091] Furthermore, the S2 specifically includes:

[0092] S201. Get the low-code configuration diagram , wherein Represents all component nodes in the page, Dependency edges are generated in real time by the platform rendering logic. Dependency edges between fields, fields and process nodes, fields and validation rules, etc. are generated in real time by the platform rendering logic;

[0093] S202, according to the low-code configuration diagram Constructing a behavior-structure fusion diagram Specifically:

[0094] Constructing a structure-behavior fusion diagram ,in Contains low-code configuration diagrams Component nodes and each behavior semantic vector in As a virtual behavior node, include:

[0095] Component dependency edges in the original structure graph;

[0096] From each behavior semantic vector node Points to its corresponding component type The edge (given by supply);

[0097] Operation frequency edge: If a component type If a node has been modified multiple times in the historical sequence, a self-loop edge is introduced to enhance its activity.

[0098] S203. Calculate the complexity score of each component based on the behavior semantic vector, combined with behavior aggregation and graph structure coupling. , expressed as:

[0099] ;

[0100] Where i represents the i-th component; It represents the sum of all behavioral semantic vectors pointing to the component, and measures the behavioral activity of the component; It is a component In low-code configuration diagram The PageRank value in , which measures its structural centrality; It is a component The number of times it has been modified in the history log; is the rule conflict penalty term, when the component When there is a logical conflict in the bound validation rules, this item is 1, otherwise it is 0; These are weight coefficients, which are set to 0.3, 0.3, 0.2, and 0.2 in practice. The tuning process is based on feedback optimization of the actual form design complexity.

[0101] in, for action intensity; is structural centrality; To modify the frequency; Penalty for rule violations.

[0102] S204: Calculate and sort the complexity scores of all components, and select the component with the highest complexity score. components as high-complexity candidate sets and generate a component complexity score table, including:

[0103] Calculate and sort the complexity scores of all components and select the top components with the highest scores. components ( Dynamically adjustable, the default setting is 15% of the total number of components on the page) as a high-complexity candidate set. To further prevent misidentification, we've added a post-hoc filtering condition: if a component has never triggered a validation failure or manual correction in historical configurations, it will be eliminated. This prevents components with statically high structural complexity but no configuration issues from being included in subsequent optimizations.

[0104] Output of this step:

[0105] Highly complex component sets ;

[0106] Component Complexity Scoring Scale , which is used by the subsequent reasoning network to set intervention priority.

[0107] As you can understand, this step fully leverages the semantic vector output from the previous step. Through a three-tiered mechanism of structural fusion, behavioral frequency fusion, and rule detection, it establishes a highly complex recognition framework for "real user build intent," distinguishing itself from traditional shallow statistical methods based on page length or node hierarchy. In particular, the introduction of the "operational semantics cumulative norm" and "rule conflict penalty factor" into the scoring function demonstrates the solution's high adaptability to the coexistence of dynamic behavior and static rule conflicts in low-code platforms, while maintaining its creative characteristics of a concise number of variables, sophisticated indicator design, and rigorous logical flow.

[0108] S3. Based on the component complexity score table and the high-complexity component set, the behavior semantic vector set and the behavior component mapping table are combined to construct a local causal subgraph in the low-code configuration diagram and generate a path semantic nesting matrix, and execute a depth limit of A DFS traversal is performed to generate a set of high-risk causal paths and assign path-level risk scores, and a subgraph edge score matrix is ​​generated.

[0109] Among them, this step aims to build on the high-complexity component set identified in step 2 And its corresponding complexity score table , combined with the user behavior semantic vector obtained in the first step and component mapping , in the low-code configuration graph structure By constructing a local causal subgraph, we can identify the causal paths within a complex region that are most likely to cause configuration conflicts, performance bottlenecks, or user errors. This step not only pinpoints the source of the problem but also provides structural context for generating subsequent optimization recommendations. This enables the decision-making support system to provide "path-level" intervention capabilities rather than just "node-level" recommendations, significantly improving the depth and accuracy of intelligent decision-making.

[0110] Among them, this step input: high complexity component set : Output from step 2, indicating the components that need to be analyzed; component complexity score table : represents the complexity score of each component (normalized); user behavior semantic vector set : Generated by step 1, describing the window-level user operation intention; behavior component mapping table : Map each behavior semantic vector to its operation object component; low-code configuration diagram : A component dependency graph automatically maintained during platform runtime, where nodes are component identifiers and edges are data / logic dependencies.

[0111] Furthermore, the S3 specifically includes:

[0112] S301: Project the behavior semantic vector onto the component node according to the behavior component mapping table to form an aggregated behavior intention representation for each component. Aggregate the corresponding semantic vector of the aggregated behavior intention representation using a weighted average method, specifically:

[0113] Establish a causal relationship between behavior, structure, and complexity. Behavior semantic vector Projected onto the component node to form each component Aggregate behavioral intention representation , and aggregate their corresponding semantic vectors using weighted average:

[0114] ;

[0115] in, Representation and Components The mapped semantic vector index set; It is A sliding window behavior semantic vector; Score complexity The normalized value of , as a regular term, enhances the causal strength; is a factor that adjusts the influence of the complexity term (recommended value: 0.15).

[0116] The innovation of this formula lies in its fusion of behavioral expression and structural complexity, establishing a vector representation of "component intent" that no longer relies solely on the structural graph topology itself. This ensures that even if the paths between some components are short, if the behavioral intent differs significantly, they are not considered high-risk coupling.

[0117] S302. In the low-code configuration graph, edges are screened by designing a causal strength scoring function to construct a local causal subgraph; the subgraph edge scoring matrix is ​​obtained based on the causal strength scoring function; wherein, the local causal subgraph satisfies:

[0118] All included and Intra-hop dependency nodes;

[0119] Keep all Side pair , where the scoring function is defined as:

[0120] ;

[0121] in, is the standard cosine similarity function; is a structural conflict indicator function: if If there are logical conflicts in the component such as field verification, data dependency, and permission control, then , otherwise 0; It is an adjustable coefficient, and the default values ​​are 0.6 and 0.4.

[0122] The construction of this function combines the two factors of behavioral intention similarity and structural conflict. The high or low judgment of the "potential strong causal dependency" between components is particularly suitable for locating user misconfiguration and complex process linkage problems in low-code scenarios.

[0123] S303: For the local causal subgraph, starting from each high-complexity component, execute a depth limit of The DFS traversal records all reachable paths and assigns a path risk score to each path. The highest path risk score indicates that the causal coupling between the components within the path is the tightest and the operation intention is the most consistent, thus forming a potential misconfiguration path or process stuck path. Specifically:

[0124] From each high-complexity component Departure, in The execution depth limit is DFS traversal, recording all reachable paths , and assign a path risk score to each path:

[0125] ;

[0126] A higher path risk score indicates tighter causal coupling between components within the path, more consistent operational intentions, and a higher likelihood of constituting a potential misconfiguration path or process stuck path.

[0127] Output: Set of high-risk causal paths , each path is a component sequence; the subgraph edge scoring matrix , which is used to filter optimization entry points when generating optimization suggestions in the next step.

[0128] S4. Taking minimizing the consistency loss within the path as the objective function, for the high-risk causal path set, combined with the behavior semantic vector set, determine an optimization suggestion draft set and a recommended positioning node set.

[0129] Furthermore, the S4 specifically includes:

[0130] S401: Perform semantic vector mapping on all nodes in each causal path in the high-risk causal path set, determine the semantic vector corresponding to the causal path, and form a path semantic nesting matrix, specifically:

[0131] For each causal path All nodes in Perform semantic vector mapping, that is, find the window behavior semantics associated with it , forming a path semantic nested matrix ,in is the semantic vector dimension (fixed to 128). This matrix expresses the operation intention corresponding to each node on the path and is the key input for subsequent suggestion generation.

[0132] S402: Based on the semantic vectors of each pair of adjacent nodes on each causal path and in combination with the subgraph edge score matrix of each pair of adjacent nodes, a matrix is ​​generated to minimize the consistency loss within the path; and the consistency loss is higher than a set threshold. The path is marked as a structurally heterogeneous path; the consistency loss is expressed as:

[0133] ;

[0134] The design of this loss function is obviously innovative: the loss only rises significantly when the two components have large semantic differences but high causal edge strength, thereby accurately locating the areas of "high coupling but semantic misalignment", which is a typical manifestation of highly complex configuration problems in low-code platforms.

[0135] S403: For the structurally heterogeneous path, based on the subgraph edge score matrix corresponding to the structurally heterogeneous path and semantic uncertainty, determine the selection weight of the structurally heterogeneous path, specifically:

[0136] Will Above the set threshold (Empirically set to 0.35) are marked as "structurally heterogeneous paths". For these paths, the system further defines the selection weight function of the proposed position , used to model the potential benefit of adjusting along this path, is as follows:

[0137] ;

[0138] in, express The set of adjacent components of ; is the average causal strength of the outgoing edges of the node; is its semantic uncertainty (defined in step 1 and approximated using information entropy); is the weighting coefficient (set to 0.6 and 0.4); Is the Sigmoid function, used to limit the weight between.

[0139] This weighting mechanism reflects the key innovation of our design of this patent: it not only considers causal propagation capabilities, but also semantic ambiguity, thereby achieving precise focusing on dangerous nodes with "high propagation and low certainty".

[0140] Taking an actual low-code work order process as an example, suppose the user configures "No permission group is set for the approver field" in a certain path and then connects it to the "process jump condition". The system detects that there is a large semantic difference between the two nodes ( ), but with a higher causality score ( ), and the semantic uncertainty of the field is high (users edited it multiple times), then If the value is obviously too high, the node will be selected as the recommended candidate node.

[0141] S404: Output all nodes that satisfy a selection weight greater than a preset threshold as candidate points for suggestion generation, and construct a set of optimization proposal drafts. Each optimization proposal draft in the set of optimization proposal drafts represents a semantic vector, a configuration snapshot, and all adjacent nodes of the current node; the set of recommended positioning nodes is obtained based on the candidate points, specifically:

[0142] The system will satisfy all Node The output is to generate candidate points for proposals and construct a structured proposal draft representation , which contains the current node semantics and configuration snapshot (taken from the context snapshot in step 1) and all adjacent nodes.

[0143] Output: A collection of draft optimization proposals , which is the input for subsequent suggestion generation or recommendation system; the set of recommended positioning nodes , for subsequent rendering or display.

[0144] S5. Map the optimization suggestion draft set and the recommended positioning node set to the low-code configuration diagram for visual annotation, automatically execute configuration modifications after structural constraint verification, and record change logs to support rollback and version tracing.

[0145] Specifically, the goal of this step is to generate the optimization suggestions set in the previous stage. and the set of positioning nodes Based on this, suggestions are visualized and structural modifications are executed. In low-code platforms, user configuration structures are often logically linked through component diagrams, so the presentation and execution of suggestions must be completed within the diagram structure. To this end, the system not only supports high-precision suggestion rendering and interaction, but also implements automatic structured modification capabilities based on configuration snapshots in the backend.

[0146] Furthermore, the S5 specifically includes:

[0147] S501. Map the draft optimization suggestion representations in the draft optimization suggestion set back to the corresponding nodes in the low-code configuration graph, quickly locate them through component ID index or timestamp mapping, and present them in a highlighted floating layer in the front-end graph structure; before performing the presentation, verify whether the change suggestion is legal under the current structure through the structural constraint relationship verification function between components;

[0148] S502. If the structural constraint relationship verification function between the components is 1, it is legal, and the structural update will be performed through the low-code configuration diagram of the back-end configuration management interface to form a new low-code configuration diagram, and the operation results will be written into the change log.

[0149] Specifically, the system first Each suggestion Mapping back to the original component diagram The corresponding node in Components are quickly located using component ID indexes or timestamp mappings, and are highlighted in the front-end graph structure as a floating overlay, along with "Suggested Type Text," "Change Parameter Content," and "Confirm / Skip" options. For example, if the suggestion is "Field F has no maximum value configured," the system will pop up a prompt for that node, "Recommend setting the maximum value to ≤ 1000," and provide a button to execute the suggestion.

[0150] Before execution, the system needs to verify the change proposal Is it legal under the current structure? This verification is done through the following function accomplish:

[0151] ;

[0152] in, It is a structural constraint relationship verification function between components, verifying whether the adjacent components have caused connectivity logic anomalies due to the modification, such as process jump breakage, invalid permission rules, etc. Represents a Boolean indicator function.

[0153] like , the system will send the configuration management interface to the component diagram Perform structural updates to form a new graph , and write the operation results to the change log:

[0154] ;

[0155] in, is the change timestamp, and These represent component configuration snapshots before and after the change, respectively. Change logs are persisted to support rollbacks and version comparisons.

[0156] For example, if the system recommends adding the data type validation rule {type: 'number'} to the component node "Field A" and verifies that all downstream nodes using this field are compatible, the system will directly inject the rule into the Field A configuration, update the graph structure version, and record the log.

[0157] Final output: new graph structure , which already contains the automatically modified configuration; change log collection , record each modification content and operation time.

[0158] like Figure 2 As shown, another embodiment of the present invention provides an AI-based low-code decision-making auxiliary system, the system comprising:

[0159] The user configuration behavior collection unit 301 is used to collect the user's event stream on the low-code platform, including: operation behavior sequence, context state snapshot and system operation resource status, construct an event vector sequence and a behavior component mapping table, and input the event vector sequence into the Transformer encoder and perform average pooling to generate a behavior semantic vector set;

[0160] A high-complexity region identification unit 302 is used to obtain a low-code configuration graph to construct a behavior-structure fusion graph, calculate the complexity score of each component by combining behavior aggregation and graph structure coupling, generate a component complexity score table and determine a high-complexity component set;

[0161] The problem path identification unit 303 is used to construct a local causal subgraph in the low-code configuration diagram based on the component complexity score table and the high-complexity component set, combined with the behavior semantic vector set and the behavior component mapping table, and generate a path semantic nesting matrix, and perform a depth limit of DFS traversal is performed to generate a set of high-risk causal paths and assign path-level risk scores, and a subgraph edge score matrix is ​​generated;

[0162] An optimization suggestion generating unit 304 is configured to determine a set of optimization suggestion drafts and a set of recommended positioning nodes for the set of high-risk causal paths in combination with the set of behavioral semantic vectors, with minimization of the consistency loss within the path as the objective function;

[0163] The suggestion visualization presentation unit 305 is used to map the optimization suggestion draft set and the suggestion positioning node set to the low-code configuration diagram for visual annotation, automatically execute configuration modifications after structural constraint verification, and record change logs to support rollback and version tracing.

[0164] It should be noted that the workflow described above is merely illustrative and does not limit the scope of protection of the present invention. In practical applications, technicians in this field can select part or all of it according to actual needs to achieve the purpose of the embodiment scheme, and no limitation is made here.

[0165] In addition, for technical details not fully described in this embodiment, please refer to the parameter operation method provided in any embodiment of the present invention, and will not be repeated here.

[0166] It should be noted that, in this document, the terms "comprises," "includes," or any other variations thereof are intended to encompass non-exclusive inclusion, such that a process, method, article, or system comprising a series of elements includes not only those elements but also other elements not explicitly listed, or elements inherent to such process, method, article, or system. In the absence of further limitations, an element defined by the phrase "comprising a ..." does not exclude the presence of other identical elements in the process, method, article, or system comprising the element.

[0167] The serial numbers of the above embodiments of the present invention are for description only and do not represent the advantages or disadvantages of the embodiments.

[0168] Through the above description of the embodiments, those skilled in the art will clearly understand that the methods of the above embodiments can be implemented using software plus the necessary general-purpose hardware platform. Of course, hardware can also be used, but in many cases the former is a more preferred implementation method. Based on this understanding, the technical solution of the present invention, or the portion that contributes to the prior art, can be embodied in the form of a software product. This computer software product is stored in a storage medium (such as read-only memory / random access memory, a magnetic disk, or an optical disk) and includes a number of instructions for enabling a terminal device (such as a mobile phone, computer, server, air conditioner, or network device) to execute the methods described in the various embodiments of the present invention.

[0169] The above are only preferred embodiments of the present invention and are not intended to limit the patent scope of the present invention. Any equivalent structure or equivalent process transformation made using the contents of the present invention description and drawings, or directly or indirectly applied in other related technical fields, are also included in the patent protection scope of the present invention.

Claims

1. A low-code decision-making method based on AI, characterized in that: The method comprises: S1. Collect the user's event stream on the low-code platform, including: operation behavior sequence, context state snapshot and system operation resource status, construct event vector sequence and behavior component mapping table, input the event vector sequence into the Transformer encoder, and perform average pooling to generate a behavior semantic vector set; S2. Obtain the low-code configuration diagram to construct a behavior-structure fusion diagram, combine behavior aggregation and graph structure coupling to calculate the complexity score of each component, generate a component complexity score table and determine the high-complexity component set; S3. Based on the component complexity score table and the high-complexity component set, the behavior semantic vector set and the behavior component mapping table are combined to construct a local causal subgraph in the low-code configuration diagram and generate a path semantic nesting matrix, and execute a depth limit of DFS traversal is performed to generate a set of high-risk causal paths and assign path-level risk scores, and a subgraph edge score matrix is ​​generated; S4. Taking minimizing the consistency loss within the path as the objective function, for the set of high-risk causal paths, combined with the set of behavioral semantic vectors, determine a set of optimization suggestion drafts and a set of recommended positioning nodes; S5. Map the optimization suggestion draft set and the recommended positioning node set to the low-code configuration diagram for visual annotation, automatically perform configuration modifications after structural constraint verification, and record change logs to support rollback and version tracing; Wherein, the S2 specifically includes: S201. Get the low-code configuration diagram , wherein Represents all component nodes in the page, Dependency edges are generated in real time by the platform rendering logic. S202, according to the low-code configuration diagram Constructing a behavior-structure fusion diagram , where the nodes Contains low-code configuration diagrams The component nodes in the and each behavior semantic vector are used as virtual behavior nodes, and the edges Includes: component dependency edges of the low-code configuration graph; edges pointing from each behavior semantic vector node to its corresponding component; operation frequency edges; S203. Calculate the complexity score of each component based on the behavior semantic vector, combined with behavior aggregation and graph structure coupling. , expressed as: ； Where i represents the i-th component; It represents the sum of all behavioral semantic vectors pointing to the component, and measures the behavioral activity of the component; It is a component In low-code configuration diagram The PageRank value in , which measures its structural centrality; It is a component The number of times it has been modified in the history log; is the rule conflict penalty term, when the component When there is a logical conflict in the bound validation rules, this item is 1, otherwise it is 0; These are weight coefficients, which are set to 0.3, 0.3, 0.2, and 0.2 in practice. The tuning process is based on feedback optimization of the actual form design complexity. S204: Calculate and sort the complexity scores of all components, and select the component with the highest complexity score. components as high-complexity candidate sets and generate a component complexity score table.

2. The low-code decision-making method based on AI according to claim 1, characterized in that: Said S1 specifically includes: S101. Obtaining event streams at the front end and back end of the low-code platform; S102, dividing the event stream into time windows, wherein the event stream in each window constitutes an operation segment; S103, performing an encoding process on all events of the operation fragment in each window to generate an event vector sequence and a behavior component mapping table; S104: Input the event vector sequence into a set of Transformer encoders comprising a two-layer structure, perform average pooling on the output of the Transformer encoder, obtain a behavior semantic vector, and construct a behavior semantic vector set.

3. The low-code decision-making method based on AI according to claim 2, characterized in that: Each behavior event in the operation behavior sequence is a five-tuple , indicating that the timestamp When the user For components The operation type is The action parameter is ; The encoding process specifically includes: Operation Type Mapped to a fixed-dimensional vector through 1-hot encoding, the components Then classify and map them according to the component family they belong to, and operate the parameters Different embedding strategies are adopted according to their formats.

4. The low-code decision-making method based on AI according to claim 1, characterized in that: The operation frequency edge is used to introduce a self-loop edge to enhance the activity of a component if it has been modified multiple times in the historical sequence.

5. The low-code decision-making method based on AI according to claim 1, characterized in that: Said S3 specifically includes: S301: Projecting the behavior semantic vector onto the component node according to the behavior component mapping table to form an aggregated behavior intention representation of each component, and aggregating the corresponding semantic vector of the aggregated behavior intention representation using a weighted average method; S302. In the low-code configuration graph, edges are screened by designing a causal strength scoring function to construct a local causal subgraph; the subgraph edge scoring matrix is ​​obtained based on the causal strength scoring function; S303: For the local causal subgraph, starting from each high-complexity component, execute a depth limit of The DFS traversal records all reachable paths and assigns a path risk score to each path. The path with the highest risk score indicates that the causal coupling between the components within the path is the tightest and the operation intention is the most consistent, thus forming a potential misconfiguration path or process stuck path.

6. The low-code decision-making method based on AI according to claim 5, characterized in that: The specific structure of the local causal subgraph is: The nodes of the local causal subgraph are a subset of the low-code configuration graph nodes, specifically including: First, all components belonging to the high-complexity component set are screened, and nodes with dependencies between the components belonging to the high-complexity component set within a 2-hop range are determined as nodes of the low-code configuration graph; The edges of the local causal subgraph retain all edges that meet the causal strength score threshold edge pair; where the causal strength score Expressed as: ； in, is the standard cosine similarity function; is a structural conflict indicator function: if the node If there is a logical conflict in the component, , otherwise 0; is an adjustable coefficient.

7. The low-code decision-making method based on AI according to claim 1, characterized in that: Said S4 specifically includes: S401, performing semantic vector mapping on all nodes in each causal path in the high-risk causal path set, determining the semantic vector corresponding to the causal path, and forming a path semantic nesting matrix; S402: Based on the semantic vectors of each pair of adjacent nodes on each causal path and in combination with the subgraph edge score matrix of each pair of adjacent nodes, a matrix is ​​generated to minimize the consistency loss within the path; and the consistency loss is higher than a set threshold. The paths are marked as structurally heterogeneous paths; S403: determining, for the structurally heterogeneous path, a selection weight of the structurally heterogeneous path based on a subgraph edge score matrix corresponding to the structurally heterogeneous path and semantic uncertainty; S404. Output all nodes that meet the selection weight greater than a preset threshold as candidate points for recommendation generation, and construct a set of optimization suggestion drafts. Each optimization suggestion draft in the set of optimization suggestion drafts represents a semantic vector, a configuration snapshot, and all adjacent nodes of the current node; the set of recommended positioning nodes is obtained based on the candidate points.

8. The low-code decision-making method based on AI according to claim 1, characterized in that: Said S5 specifically includes: S501. Map the draft optimization suggestion representations in the draft optimization suggestion set back to the corresponding nodes in the low-code configuration graph, quickly locate them through component ID index or timestamp mapping, and present them in a highlighted floating layer in the front-end graph structure; before executing the presentation, verify whether the change suggestion is legal under the current structure through the structural constraint relationship verification function between components; S502. If the structural constraint relationship verification function between the components is 1, it is legal, and the structural update will be performed through the low-code configuration diagram of the back-end configuration management interface to form a new low-code configuration diagram, and the operation results will be written into the change log.

9. A system for executing the AI-based low-code decision-making method according to claim 1, characterized in that: The system comprises: The user configures a behavior collection unit to collect the user's event stream on the low-code platform, including: operation behavior sequence, context state snapshot, and system operation resource status, construct an event vector sequence and behavior component mapping table, and input the event vector sequence into the Transformer encoder and perform average pooling to generate a behavior semantic vector set; High-complexity area identification unit, used to obtain low-code configuration diagrams to construct behavior-structure fusion diagrams, combine behavior aggregation and graph structure coupling to calculate the complexity score of each component, generate a component complexity score table and identify high-complexity component sets; A problem path identification unit is used to construct a local causal subgraph in the low-code configuration diagram based on the component complexity score table and the high-complexity component set, combined with the behavioral semantic vector set and the behavioral component mapping table, and generate a path semantic nesting matrix, and perform a depth limit of DFS traversal is performed to generate a set of high-risk causal paths and assign path-level risk scores, and a subgraph edge score matrix is ​​generated; An optimization suggestion generating unit, configured to determine a set of optimization suggestion drafts and a set of recommended positioning nodes for the set of high-risk causal paths in combination with the set of behavioral semantic vectors, with minimization of the consistency loss within the path as the objective function; A suggested visual presentation unit is used to map the optimization suggestion draft set and the suggested positioning node set to the low-code configuration diagram for visual annotation, automatically execute configuration modifications after structural constraint verification, and record change logs to support rollback and version tracing.

Images