An automated processing method and apparatus for task flow

Abstract

This application provides an automatic task flow processing method and apparatus. The method includes: acquiring user drag-and-drop operations and parameter configurations of preset components in a display interface; generating a graphical processing flow based on the drag-and-drop operations and parameter configurations of the preset components; logically transforming the graphical processing flow to obtain an executable script; predicting user design intent from the generated executable script and generating optimization suggestions for the executable script to obtain a general task flow; parsing the general task flow based on scenario identifiers to convert the general task flow into a task format required by the execution system corresponding to the target scenario; and dynamically allocating and executing tasks according to priority and resource load based on the task format required by the execution system corresponding to the target scenario. This solution achieves the technical effect of improving the ability to process unstructured data and make dynamic decisions, and realizing low-code development and rapid adaptation to multiple scenario requirements.

Description

Technical Field

[0001] This application belongs to the field of artificial intelligence technology, and in particular relates to an automatic processing method and apparatus for task flow. Background Technology

[0002] Existing RPA (Robotic Process Automation) systems typically improve business process efficiency by simulating a human user interface and performing repetitive tasks (such as data entry, data extraction, and form processing) based on preset rules.

[0003] However, as enterprise application scenarios become more complex, existing RPA systems will inevitably have the following problems:

[0004] 1) Low level of intelligence: RPA systems (e.g., commercial platforms like UiPath and Blue Prism) primarily rely on rule engines. When processing unstructured data (e.g., natural language text, image files), complex scripts need to be written manually, making it impossible to achieve advanced functions such as semantic understanding and dynamic decision-making. For example, in contract review scenarios, existing RPA systems cannot automatically identify compliance risks in key clauses.

[0005] 2) The conflict between development efficiency and flexibility: While low-code development platforms (such as Microsoft PowerAutomate) lower the development threshold through visual drag-and-drop, their modular component libraries have limited extensibility, failing to meet the differentiated needs of various scenarios across industries. Statistics show that enterprises typically need to invest an average of 3-6 months in customized development when deploying cross-departmental RPA.

[0006] 3) Lack of dynamic adaptability: The current system lacks a self-learning mechanism. When business processes change (e.g., tax policy adjustments lead to changes in reimbursement rules), the process logic needs to be manually reconfigured, resulting in maintenance costs accounting for more than 60% of the system's total lifecycle cost.

[0007] 4) Weak support for multimodal interaction: Existing RPA systems' integration of AI technologies such as voice commands and image recognition remains at the level of functional overlay, and has not yet achieved end-to-end automated closed loop between multimodal input and business processes. For example, in customer service scenarios, the system cannot directly convert voice call content into work order processing workflows.

[0008] There is currently no effective solution to the above problems. Summary of the Invention

[0009] The purpose of this application is to provide an automatic task flow processing method and apparatus. By building an extensible industry scenario component library, it supports the automatic generation of task flows, thereby improving the ability to process unstructured data and make dynamic decisions, and achieving the goal of low-code development and rapid adaptation to multiple scenario requirements.

[0010] This application provides an automatic task flow processing method and apparatus, which are implemented as follows:

[0011] An automatic task flow processing method, the method comprising:

[0012] The system obtains the user's drag-and-drop operations and parameter configurations of preset components in the display interface, and generates a graphical processing flow based on the drag-and-drop operations and parameter configurations of the preset components. Each preset component supports parameter configuration.

[0013] The graphical processing flow is logically transformed to obtain an executable script;

[0014] The generated executable script is subjected to user design intent prediction, and optimization suggestions are generated for the executable script to obtain a general task flow;

[0015] The general task flow is parsed based on the scene identifier in the general task flow to convert the general task flow into the task format required by the execution system corresponding to the target scene;

[0016] The task format required by the execution system corresponding to the target scenario is dynamically allocated and executed based on priority and resource load.

[0017] In one implementation, after obtaining the user's drag-and-drop operations and parameter configurations of preset components in the display interface, and generating a graphical processing flow based on the drag-and-drop operations and parameter configurations of the preset components, the process further includes:

[0018] Receive user voice commands, wherein the voice commands carry instructions for adjusting nodes in the processing flow;

[0019] The voice commands are intelligently parsed, and the graphical processing flow is adjusted to form an adjusted graphical processing flow.

[0020] In one implementation, the graphical processing flow is logically transformed to obtain an executable script, including:

[0021] The three-layer compilation architecture is invoked, wherein the three-layer compilation architecture includes: a component semantic parsing layer, an intermediate representation layer, and a target code generation layer;

[0022] By invoking a three-tier compilation architecture, the graphical processing flow is logically transformed to obtain an executable script.

[0023] In one implementation, the graphical processing flow is logically transformed to obtain an executable script, including:

[0024] Retrieve a pre-established mapping rule library between pre-built components and code;

[0025] The weights of the paths that the pre-built components depend on are calculated using the mapping rule base.

[0026] By combining the weights of the paths on which the pre-built components depend, weight mutation detection is performed based on the topological sorting of the directed graph;

[0027] If the test passes, the graphical processing flow is converted into executable code using a dynamic template engine, and an executable script is output.

[0028] In one implementation, generating optimization suggestions for the executable script includes:

[0029] The AI ​​engine receives execution logs via a message queue;

[0030] The AI ​​engine analyzes the execution logs to obtain optimization suggestions for the executable script;

[0031] Optimization suggestions for the executable script will be pushed to the low-code platform;

[0032] Users can perform optimization and confirmation operations on the executable script on a low-code platform.

[0033] In one implementation, the generated data processing stream is subjected to user design intent prediction, and optimization suggestions are generated for the data processing stream to obtain a general task flow, including:

[0034] Collect historical process execution logs, wherein the process execution logs include at least one of the following: execution time, error rate, and resource consumption;

[0035] Extract feature data of key features from the process execution log, wherein the key features include at least one of the following: process complexity, API call frequency, and data volume;

[0036] The preset prediction model is trained using the feature data;

[0037] The trained prediction model is used to predict the optimal process parameters of the generated data processing stream, wherein the process parameters include at least one of the following: concurrency and timeout threshold.

[0038] In one implementation, training a preset prediction model using the feature data includes:

[0039] A four-dimensional indicator system is constructed, comprising the following dimensions: timeliness, resource consumption, anomaly correlation, and scenario complexity. Timeliness is characterized by step delay rate, extracted using sliding window statistics. Resource consumption is characterized by peak CPU usage, extracted using monitoring. Anomaly correlation is characterized by error propagation tree depth, extracted using graph neural networks. Scenario complexity is characterized by unstructured data processing density, extracted using text vectorization and clustering.

[0040] A pre-defined prediction model is established using a four-dimensional indicator system. The pre-defined prediction model includes a feature vector input layer, a multi-head attention layer, and a dual-branch output layer. The two outputs of the dual-branch output layer are the concurrency prediction and the timeout threshold prediction.

[0041] In one implementation, the general task flow is parsed based on the scenario identifier in the general task flow to convert the general task flow into a task format required by the execution system corresponding to the target scenario, including:

[0042] The multi-scene adapter is invoked, wherein the multi-scene adapter includes scene templates corresponding to each scene in multiple scenes, and each scene template includes: data conversion rules and dedicated interfaces;

[0043] Obtain the scene identifier from the general task flow;

[0044] The scene template corresponding to the multi-scene adapter is obtained based on the scene identifier and used as the target template.

[0045] By using the data conversion rules of the target template, the format of the general task flow is converted into the task format required by the execution system corresponding to the target scenario;

[0046] After parsing is complete, the dedicated interface in the target template is called to send the converted task format to the execution system corresponding to the target scenario.

[0047] In one implementation, dynamic allocation and execution of tasks based on priority and resource load includes:

[0048] The collaborative scheduling center obtains the execution priority of tasks corresponding to each target scenario;

[0049] The scheduling center uses a weighted round-robin approach to execute tasks in descending order of priority according to the execution priority of the tasks corresponding to each target scenario.

[0050] If a task fails during execution and the number of automatic retries exceeds the preset number of executions, the task will be transferred to a backup node for execution. The status of each execution node will be monitored in real time. If a failed execution node is identified, it will be removed as a faulty node.

[0051] An apparatus for automatically generating and processing task flows, comprising:

[0052] The acquisition module is used to acquire the user's drag-and-drop operations and parameter configurations of the preset components in the display interface, and generate a graphical processing flow based on the drag-and-drop operations and parameter configurations of the preset components. Each preset component supports parameter configuration.

[0053] The conversion module is used to logically convert the graphical processing flow to obtain an executable script.

[0054] The prediction module is used to predict the user's design intent in the generated executable script and generate optimization suggestions for the executable script to obtain a general task flow;

[0055] The parsing module is used to parse the general task flow according to the scene identifier in the general task flow, so as to convert the general task flow into the task format required by the execution system corresponding to the target scene;

[0056] The execution module is used to dynamically allocate and execute tasks according to priority and resource load, based on the task format required by the execution system corresponding to the target scenario.

[0057] An electronic device includes a processor and a memory for storing processor-executable instructions, wherein the processor, when executing the instructions, implements the steps of the method described above.

[0058] A computer-readable storage medium having a computer program / instructions stored thereon, which, when executed by a processor, implement the steps of the above-described method.

[0059] The automatic task flow processing method and apparatus provided in this application generate a graphical processing flow based on user drag-and-drop operations and parameter configurations of preset components. Then, the graphical processing flow undergoes logical transformation to obtain an executable script. Further, the generated executable script is used to predict user design intent and generate optimization suggestions to obtain a general task flow. The general task flow is then parsed based on scenario identifiers to convert it into a task format required by the execution system corresponding to the target scenario. The task format required by the execution system corresponding to the target scenario is then dynamically allocated and executed based on priority and resource load. This solution addresses the technical problems of existing RPA systems, such as low intelligence, lack of dynamic adaptability, and weak multimodal interaction support. It achieves improved capabilities in unstructured data processing and dynamic decision-making, enabling low-code development and rapid adaptation to multiple scenario requirements. Attached Figure Description

[0060] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments recorded in this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0061] Figure 1 This is a flowchart of one embodiment of the automatic task flow processing method provided in this application;

[0062] Figure 2 This is a flowchart of a method for logically converting a graphical processing flow according to an embodiment of the present application.

[0063] Figure 3 This is a flowchart of a method for parsing a general task flow according to an embodiment of the present application;

[0064] Figure 4 This is a schematic diagram of the architecture of one embodiment of the multi-scenario intelligent RPA system provided in this application;

[0065] Figure 5 This is a schematic diagram of the architecture of one embodiment of the prediction model provided in this application;

[0066] Figure 6 This is a hardware structure block diagram of an electronic device for an automatic task flow processing method provided in this application;

[0067] Figure 7 This is a schematic diagram of the module structure of an embodiment of the automatic task flow processing device provided in this application. Detailed Implementation

[0068] To enable those skilled in the art to better understand the technical solutions in this application, the technical solutions in the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of this application.

[0069] Existing RPA systems rely on manually pre-defined rules, making them ineffective at handling semantic understanding and dynamic decision-making for unstructured data (e.g., contract texts, voice recordings). For example, in financial reimbursement scenarios, existing systems require manual writing of regular expressions to extract invoice information, resulting in low accuracy in recognizing fuzzy fields (e.g., handwritten amounts), leading to a large number of tasks still requiring manual review. Furthermore, the separation of low-code platforms from AI technology results in a lack of intelligent process optimization capabilities. While existing low-code development tools offer visual process design, the scalability of their modular components is limited.

[0070] This example provides a method for automating task flow processing. Figure 1 This is a flowchart illustrating one embodiment of the automated task flow processing method provided in this application. While this application provides method operation steps or apparatus structures as shown in the following embodiments or figures, more or fewer operation steps or module units may be included in the method or apparatus based on conventional or non-inventive effort. In steps or structures where there is no logically necessary causal relationship, the execution order of these steps or the module structure of the apparatus is not limited to the execution order or module structure described in the embodiments and figures of this application. When the method or module structure is applied in actual devices or terminal products, it can be executed sequentially or in parallel according to the method or module structure shown in the embodiments or figures (e.g., in a parallel processor or multi-threaded processing environment, or even a distributed processing environment).

[0071] Specifically, such as Figure 1 As shown, the above-mentioned automatic task flow processing method may include the following steps:

[0072] Step 101: Obtain the user's drag-and-drop operations and parameter configurations for the preset components in the display interface, and generate a graphical processing flow based on the drag-and-drop operations and parameter configurations for the preset components. Each preset component supports parameter configuration.

[0073] In practical implementation, considering that the processing flow formed by user dragging and dropping may sometimes be incorrect or require modification, voice modification commands can be added to modify the formed processing flow through voice interaction. Specifically, after obtaining the user's dragging operations and parameter configurations of preset components in the display interface, and generating a graphical processing flow based on the dragging operations and parameter configurations of the preset components, the implementation may further include: receiving the user's voice command, wherein the voice command carries an adjustment instruction for nodes in the processing flow; intelligently parsing the voice command, adjusting the graphical processing flow, and forming an adjusted graphical processing flow.

[0074] For example, the second step of the established process is "XX leader confirms", but the user finds that it should actually be "YY leader confirms". Based on this, the user can change "XX leader confirms" to "YY leader confirms" in the second step using voice commands, thus achieving simple and efficient modification based on voice commands.

[0075] Step 102: Perform logical transformation on the graphical processing flow to obtain an executable script;

[0076] Specifically, a three-layer compilation architecture can be invoked, which includes a component semantic parsing layer, an intermediate representation layer, and a target code generation layer. By invoking the three-layer compilation architecture, the graphical processing flow is logically transformed to obtain an executable script.

[0077] For example, in implementation, the following three-tier compilation architecture is used to convert graphics into executable scripts:

[0078] A. Component semantic parsing layer:

[0079] Establish a component-code mapping rule library, for example: "Data Validation" component → if-else + regex code block;

[0080] Collision detection based on directed graph topological sorting:

[0081]

[0082] B. Intermediate Representation Layer (IR):

[0083] Transform the graphical logic into a unified intermediate representation (JSON-based IR Schema):

[0084]

[0085] C. Target code generation layer:

[0086] Generate executable code based on a dynamic template engine (Python / UiBot):

[0087]

[0088]

[0089] return render(template,ir) # Outputs the executable script

[0090] For example, when designing an "automatic expense reimbursement process", users drag and drop the "Read Excel Spreadsheet" → "Validate Data" → "Submit to Financial System" components, and the platform generates the corresponding script code.

[0091] Specifically, interaction can be achieved as follows: users drag and drop components onto the canvas and define the execution order by connecting them. Each component supports parameter configuration (e.g., API URL, database connection information). Furthermore, real-time syntax checking and logic validation are provided to avoid design errors.

[0092] Step 103: Predict user design intent for the generated executable script and generate optimization suggestions for the executable script to obtain a general task flow;

[0093] In one implementation, generating optimization suggestions for the executable script may include: an AI engine receiving execution logs via a message queue; the AI ​​engine analyzing the execution logs to obtain optimization suggestions for the executable script; pushing the optimization suggestions to a low-code platform; and the user performing optimization and confirmation operations on the low-code platform. In other words, AI can be introduced to optimize executable scripts, achieving a simple and efficient optimization process.

[0094] In practice, optimization can be achieved by building a predictive model. This predictive model can be built as follows:

[0095] S1: Collect historical process execution logs, wherein the process execution logs include at least one of the following: execution time, error rate, and resource consumption;

[0096] S2: Extract the feature data of key features from the process execution log, wherein the key features include at least one of the following: process complexity, API call frequency, and data volume;

[0097] S3: Train the preset prediction model using the feature data;

[0098] S4: Predict the optimal process parameters for the generated data processing stream using the trained prediction model, wherein the process parameters include at least one of the following: concurrency and timeout threshold.

[0099] The aforementioned pre-defined prediction model can be established in the following manner:

[0100] 1) Construct a four-dimensional indicator system, in which the dimensions include: timeliness, resource consumption, anomaly correlation, and scenario complexity. Timeliness is characterized by step delay rate, extracted using sliding window statistics; resource consumption is characterized by peak CPU usage, extracted using monitoring; anomaly correlation is characterized by error propagation tree depth, extracted using graph neural networks; and scenario complexity is characterized by unstructured data processing density, extracted using text vectorization and clustering.

[0101] 2) Establish a preset prediction model through a four-dimensional indicator system. The preset prediction model includes: a feature vector input layer, a multi-head attention layer, and a dual-branch output layer. The two outputs of the dual-branch output layer are the concurrency prediction and the timeout threshold prediction.

[0102] The aforementioned prediction model can employ a hybrid model combining supervised learning (e.g., LSTM neural networks) and unsupervised learning (e.g., clustering algorithms), which can overcome the limitations of traditional isolated model training and achieve joint optimization of dynamic scene perception.

[0103] A. Unsupervised channeling based on scene clustering:

[0104] Using an improved density clustering algorithm (ADBSCAN):

[0105] CorePoint=\left\{x_i|N_\epsilon(x_i)\geq MinPts\right\}

[0106] \epsilon_{adaptive}=\frac{\sum||x_i-\mu||^2}{N}\times\log(1+recency)

[0107] Dynamically adjust the cluster radius ε (weighted according to the timeliness of process execution).

[0108] B. Supervision channel based on LSTM optimizer:

[0109] Temporal networks incorporating attention mechanisms (AT-LSTM):

[0110] h_t=LSTM(x_t\oplus c_k,h_{t-1})

[0111] \alpha_t=\frac{\exp(score(h_t))}{\sum_t\exp(score(h_t))}

[0112] \end{align*}.

[0113] Where $c_k$ is the scene feature vector output by the clustering channel.

[0114] C. Model collaboration mechanism:

[0115] The clustering results serve as the initial scene feature input for the LSTM, and the error rate output by the LSTM is fed back to the clustering module to adjust the MinPts parameters.

[0116] Step 104: Parse the general task flow according to the scene identifier in the general task flow to convert the general task flow into the task format required by the execution system corresponding to the target scene;

[0117] Step 105: Dynamically allocate and execute tasks according to priority and resource load based on the task format required by the execution system corresponding to the target scenario.

[0118] In one implementation, the graphical processing flow is logically transformed to obtain an executable script, such as... Figure 2 As shown, it may include the following steps:

[0119] Step 201: Retrieve the pre-established mapping rule library between pre-built components and code;

[0120] Step 202: Calculate the weights of the paths that the pre-defined components depend on using the mapping rule base;

[0121] Step 203: Combine the weights of the paths that the pre-built components depend on, and perform weight mutation detection based on the directed graph topology sort;

[0122] Step 204: If the detection passes, the graphical processing flow is converted into executable code using a dynamic template engine, and an executable script is output.

[0123] To achieve multi-scenario adaptation, this example provides a multi-scenario adapter, which is middleware used to convert general process logic into executable tasks for specific business scenarios (e.g., financial reimbursement, HR onboarding). Based on this, the general task flow is parsed according to the scenario identifier in the general task flow to convert it into the task format required by the execution system corresponding to the target scenario, as shown below. Figure 3 As shown, it may include the following steps:

[0124] Step 301: Retrieve the multi-scene adapter, wherein the multi-scene adapter includes scene templates corresponding to each scene in multiple scenes, and each scene template includes: data conversion rules and dedicated interfaces;

[0125] Step 302: Obtain the scene identifier in the general task flow;

[0126] Step 303: Match the scene template corresponding to the scene in the multi-scene adapter based on the scene identifier, and use it as the target template;

[0127] Step 304: Using the data conversion rules of the target template, convert the format of the general task flow into the task format required by the execution system corresponding to the target scenario;

[0128] Step 305: After parsing is complete, call the dedicated interface in the target template to send the converted task format to the execution system corresponding to the target scenario.

[0129] For example, preset templates can be used for scenarios such as finance, HR, and IT operations, with each template containing dedicated interfaces and data conversion rules. For instance, for the finance scenario, it integrates with ERP systems to support voucher generation and report export; for the HR scenario, it integrates with recruitment platforms to automatically screen resumes and send interview invitations. Specifically, it can convert common data formats to the format required by the target system; for example, it can convert the "employee information" JSON data output by the low-code platform into the XML input format of the SAP HR module.

[0130] Considering that tasks can be dynamically allocated based on priority (e.g., financial tasks > HR tasks) and resource load (e.g., CPU / memory utilization), a weighted round-robin approach is adopted to ensure that high-priority tasks are executed first, while avoiding the problem of single node overload. Accordingly, the dynamic allocation and execution of tasks based on priority and resource load can include: a collaborative scheduling center obtaining the execution priority of tasks corresponding to each target scenario; the scheduling center using a weighted round-robin approach to execute tasks in descending order of priority according to the execution priority of tasks corresponding to each target scenario; during task execution, if a task execution failure is detected and the number of automatic retries exceeds the preset number of executions, the task is transferred to a backup node for execution, and the status of each execution node is monitored in real time. If a failed execution node is identified, it is removed as a faulty node.

[0131] The above method will be described below with reference to a specific embodiment. However, it should be noted that this specific embodiment is only for better illustration of this application and does not constitute an improper limitation of this application.

[0132] To address the limitations of existing RPA systems in automating and dynamically optimizing intelligent processes across multiple scenarios and resolving data silos across different scenarios, this example proposes combining low-code architecture with a multi-scenario intelligent RPA system. This leverages the limitations of rule engines to automate advanced tasks such as contract text compliance review and fuzzy image field extraction, aiming to improve the accuracy of unstructured data processing to over 92%. By building an extensible industry scenario component library, the system supports the automatic generation of process logic through natural language descriptions (e.g., inputting "generate employee onboarding approval process" will output a complete flowchart), shortening the cross-system deployment cycle to 3-5 days. This enhances unstructured data processing and dynamic decision-making capabilities, enabling rapid adaptation to low-code development and multi-scenario requirements.

[0133] Specifically, this example provides a multi-scenario intelligent RPA system, which can, for example... Figure 4 As shown, it includes:

[0134] 1) A low-code design platform, a development tool for quickly building applications through a visual interface and minimal coding. Core functionalities include drag-and-drop components, logic orchestration, and automated testing. It provides a visual drag-and-drop interface, allowing users to design automated processes using pre-defined components (e.g., data input boxes, logic decision nodes, API call nodes, loop structures, etc.).

[0135] The component libraries in a low-code design platform can be categorized as follows:

[0136] Data manipulation classes are used for data scraping, form filling, database querying, etc.

[0137] Logic control classes include conditional branching (IF-ELSE), looping (FOR / WHILE), and exception handling (TRY-CATCH).

[0138] Service integration class, HTTP requests, and third-party API calls.

[0139] For low-code design platforms, script generation can be achieved by converting graphical logic into executable scripts after the user completes the process design. The executable scripts are Python or RPA-specific languages ​​such as UiPath / UiBot, and can be exported with one click or directly deployed to execution nodes.

[0140] Specifically, in implementation, a three-tier compilation architecture can be used to convert graphics into executable scripts:

[0141] A. Component semantic parsing layer:

[0142] Establish a component-code mapping rule library, for example: "Data Validation" component → if-else + regex code block;

[0143] Collision detection based on directed graph topological sorting:

[0144]

[0145] B. Intermediate Representation Layer (IR):

[0146] Transform the graphical logic into a unified intermediate representation (JSON-based IR Schema):

[0147]

[0148] C. Target code generation layer:

[0149] Generate executable code based on a dynamic template engine (Python / UiBot):

[0150]

[0151] For example, when designing an "automatic expense reimbursement process", users drag and drop the "Read Excel Spreadsheet" → "Validate Data" → "Submit to Financial System" components, and the platform generates the corresponding script code.

[0152] Specifically, interaction can be achieved as follows: users drag and drop components onto the canvas and define the execution order by connecting them. Each component supports parameter configuration (e.g., API URL, database connection information). Furthermore, real-time syntax checking and logic validation are provided to avoid design errors.

[0153] 2) The AI ​​engine module breaks through the limitations of traditional isolated model training and achieves joint optimization of dynamic scene perception.

[0154] Specifically, a hybrid model is adopted that combines supervised learning (e.g., LSTM neural networks) with unsupervised learning (e.g., clustering algorithms).

[0155] A. Unsupervised channeling based on scene clustering:

[0156] Using an improved density clustering algorithm (ADBSCAN):

[0157] CorePoint=\left\{x_i|N_\epsilon(x_i)\geq MinPts\right\}

[0158] \epsilon_{adaptive}=\frac{\sum||x_i-\mu||^2}{N}\times\log(1+recency)

[0159] Dynamically adjust the cluster radius ε (weighted according to the timeliness of process execution).

[0160] B. Supervision channel based on LSTM optimizer:

[0161] Temporal networks incorporating attention mechanisms (AT-LSTM):

[0162] h_t=LSTM(x_t\oplus c_k,h_{t-1})

[0163] \alpha_t=\frac{\exp(score(h_t))}{\sum_t\exp(score(h_t))}

[0164] \end{align*}

[0165] Where $c_k$ is the scene feature vector output by the clustering channel.

[0166] C. Model collaboration mechanism:

[0167] The clustering results serve as the initial scene feature input for the LSTM, and the error rate output by the LSTM is fed back to the clustering module to adjust the MinPts parameters.

[0168] For the AI ​​engine module, data processing may include:

[0169] S1: Historical Data Collection

[0170] Collect process execution logs, which may include: execution time, error rate, and resource consumption.

[0171] S2: Feature Extraction

[0172] Extract key features, which may include: process complexity, API call frequency, and data volume.

[0173] S3: Model Training

[0174] The optimization model is trained based on feature data to predict the optimal process parameters, which may include: concurrency and timeout threshold.

[0175] Specifically, the model can be trained in the following ways:

[0176] S31: Construct the four-dimensional indicator system shown in Table 1 below:

[0177] Table 1

[0178] Dimension Feature Examples Extraction method Timeliness Step delay rate Sliding window statistics Resource consumption CPU / Mem peak Prometheus monitoring Abnormal correlation Error propagation tree depth Graph Neural Networks (GNNs) Scene complexity Unstructured data processing density Text vectorization + clustering

[0179] S32: Establish a prediction model, wherein the prediction model can be as follows: Figure 5 As shown, it includes: a feature vector input layer, a multi-head attention layer, and a dual-branch output layer. The two outputs of the dual-branch output layer are: concurrency prediction and timeout threshold prediction.

[0180] The branch-weighted loss function for the dual-branch output layer is:

[0181] Loss=\alpha\cdot MSE(concurrency)+\beta\cdot CrossEntropy(timeout)

[0182] \alpha=1-\frac{resource\_util}{100},\beta=fault\_rate^{0.5}

[0183] S33: Perform online model updates:

[0184] Incremental learning is performed using a sliding window: model.partial_fit(X_new, y_new,

[0185] classes = np.unique(y_new),

[0186] sample_weight = time_decay)

[0187] The time decay factor is: time_decay = 2**(-(current_time - event_time) / halflife)

[0188] S4: Dynamic Optimization

[0189] The system monitors the process execution in real time. If a decrease in efficiency is detected (e.g., a step takes 20% longer), the model is triggered to recalculate and adjust the parameters.

[0190] For example, in the "order processing flow", if the AI ​​model detects a response delay of a certain API, it will automatically switch to a backup interface or adjust the retry strategy.

[0191] During interaction, the AI ​​engine can receive execution logs through a message queue (e.g., Kafka), analyze them, and push optimization suggestions to the low-code platform. Users can then choose to apply the optimizations automatically or confirm them manually.

[0192] 3) Multi-scenario adapters are middleware used to convert general process logic into executable tasks for specific business scenarios (e.g., financial reimbursement, HR onboarding), including functions such as data format conversion and interface protocol adaptation.

[0193] It offers pre-set templates for scenarios such as finance, HR, and IT operations, with each template including dedicated interfaces and data transformation rules. For example, for the finance scenario, it integrates with ERP systems to support voucher generation and report export; for the HR scenario, it integrates with recruitment platforms to automatically screen resumes and send interview invitations.

[0194] Specifically, common data formats can be converted to the format required by the target system. For example, the "employee information" JSON data output by the low-code platform can be converted to the XML input format of the SAP HR module.

[0195] The multi-scenario adapter provides a RESTful API gateway that supports dynamic routing, such as distributing requests to the corresponding backend services based on scenario identifiers.

[0196] In implementation, the multi-scenario adapter can receive general tasks generated by the low-code platform, parse the scenario identifiers in the general tasks, and then call the corresponding interfaces after parsing. Next, it converts the general data format to the format required by the target system. If the conversion fails, it logs the error and notifies the scheduling center to retry or provide manual intervention.

[0197] 4) Collaborative Dispatch Center:

[0198] Tasks are dynamically allocated based on priority (e.g., financial tasks > HR tasks) and resource load (e.g., CPU / memory utilization). Weighted round-robin is used to ensure that high-priority tasks are executed first, while avoiding overload on a single node.

[0199] During execution, if a task fails and automatically retryes three times without success, it is transferred to a backup node. Furthermore, the status of nodes is monitored in real time, and faulty nodes are automatically removed upon detection of a failure.

[0200] The collaborative scheduling center can also perform log management, such as recording task execution details (e.g., start / end time, resource consumption, error messages) and storing the task execution details in Elasticsearch for query and analysis.

[0201] In implementation, the scheduling center can manage the list of execution nodes using ZooKeeper. After receiving tasks submitted by the low-code platform, it allocates them to idle nodes according to a strategy. The task status is then pushed to the user dashboard in real time via WebSocket.

[0202] The end-to-end workflow of the aforementioned multi-scenario intelligent RPA system can include:

[0203] S1: User Design Phase

[0204] Users can design an "employee onboarding process" on a low-code platform by dragging and dropping components, including steps such as "reading resumes" → "generating employee IDs" → "granting system permissions".

[0205] S2: AI Optimization Phase

[0206] The AI ​​engine module analyzes historical data and suggests breaking down the "granting permissions" step into parallel tasks to shorten the total time.

[0207] S3: Scene Adaptation Stage

[0208] The multi-scenario adapter transforms common processes into Jira API call instructions for IT operations and maintenance scenarios.

[0209] S4: Task Execution Phase

[0210] The scheduling center assigns tasks to edge computing nodes for execution and monitors the progress and provides feedback on the results in real time.

[0211] In practical applications, the visual drag-and-drop code generator can also employ an AI code generator based on natural language descriptions (e.g., user-inputted requirement text) to automatically generate process scripts, replacing visual interface operations. Furthermore, for the expansion of the modular component library, pre-built functional modules (e.g., "data scraping," "form filling," etc.) can be provided, allowing users to complete process design by combining modules, thereby reducing development complexity.

[0212] The aforementioned AI engine module can employ reinforcement learning instead of supervised learning, using reinforcement learning algorithms to dynamically optimize process logic and adjust parameters based on environmental feedback, thus replacing supervised learning models based on historical data. Alternatively, it can utilize multi-model collaborative decision-making, integrating multiple AI models (e.g., decision trees, neural networks) for voting or weighted decision-making to enhance the robustness of process optimization.

[0213] The aforementioned multi-scenario adapters can replace dedicated interfaces with a universal API gateway. A unified API gateway receives task requests and uses dynamic routing technology to distribute them to backend services in different scenarios, reducing the need for customized interface development. Alternatively, they can be based on semantic recognition-based data transformation, utilizing semantic analysis techniques (such as knowledge graphs) to automatically match data fields from different scenarios, replacing manually predefined transformation rules.

[0214] The aforementioned collaborative scheduling center can also replace centralized scheduling with distributed task queues, using distributed message queues (e.g., Kafka, RabbitMQ) to achieve asynchronous task allocation, thereby improving system throughput and fault tolerance. Alternatively, a lightweight scheduling module can be deployed on local edge devices, such as edge computing nodes, to reduce cloud dependency and suitability for scenarios with high real-time requirements.

[0215] In the example above, a deep integration of a low-code platform and an AI engine was employed. Based on a joint training mechanism using component drag-and-drop behavior and historical process data, the AI ​​model was able to predict user design intent in real time and generate optimization suggestions. An automated conversion of data formats across multiple scenarios was achieved through a mapping library between JSON Schema and scene identifiers. A dynamic feedback mechanism based on priority weights and node resource load enabled elastic scaling of task allocation.

[0216] The methods and embodiments provided in the above-described embodiments of this application can be executed in a mobile terminal, computer terminal, or similar computing device. Taking operation on an electronic device as an example... Figure 6 This is a hardware structure block diagram of an electronic device for an automated task flow processing method provided in this application. (See diagram for example.) Figure 6 As shown, the electronic device 10 may include one or more (only one is shown in the figure) processors 02 (processors 02 may include, but are not limited to, microprocessors MCUs or programmable logic devices FPGAs, etc.), a memory 04 for storing data, and a transmission module 06 for communication functions. Those skilled in the art will understand that... Figure 6 The structure shown is for illustrative purposes only and does not limit the structure of the electronic device described above. For example, electronic device 10 may also include... Figure 6 The more or fewer components shown, or having the same Figure 6 The different configurations shown.

[0217] The memory 04 can be used to store software programs and modules of application software, such as the program instructions / modules corresponding to the automatic task flow processing method in this embodiment of the application. The processor 02 executes various functional applications and data processing by running the software programs and modules stored in the memory 04, thereby realizing the above-mentioned automatic task flow processing method of the application. The memory 04 may include high-speed random access memory, and may also include non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some instances, the memory 04 may further include memory remotely located relative to the processor 02, and these remote memories can be connected to the electronic device 10 via a network. Examples of the above-mentioned networks include, but are not limited to, the Internet, corporate intranets, local area networks, mobile communication networks, and combinations thereof.

[0218] The transmission module 06 is used to receive or send data via a network. Specific examples of the network described above may include a wireless network provided by the communication provider of the electronic device 10. In one example, the transmission module 06 includes a Network Interface Controller (NIC), which can connect to other network devices via a base station to communicate with the Internet. In another example, the transmission module 06 may be a Radio Frequency (RF) module, used for wireless communication with the Internet.

[0219] At the software level, the aforementioned automated task flow processing device can be as follows: Figure 7 As shown, it includes:

[0220] The acquisition module 701 is used to acquire the user's drag-and-drop operations and parameter configurations of preset components in the display interface, and to generate a graphical processing flow based on the drag-and-drop operations and parameter configurations of the preset components. Each preset component supports parameter configuration.

[0221] The conversion module 702 is used to logically convert the graphical processing flow to obtain an executable script.

[0222] The prediction module 703 is used to predict the user design intent of the generated executable script and generate optimization suggestions for the executable script to obtain a general task flow;

[0223] The parsing module 704 is used to parse the general task flow according to the scene identifier in the general task flow, so as to convert the general task flow into the task format required by the execution system corresponding to the target scene;

[0224] The execution module 705 is used to dynamically allocate and execute tasks based on priority and resource load, according to the task format required by the execution system corresponding to the target scenario.

[0225] In one embodiment, after acquiring the user's drag-and-drop operations and parameter configurations of preset components in the display interface, and generating a graphical processing flow based on the drag-and-drop operations and parameter configurations of the preset components, the acquisition module 701 can also receive the user's voice commands, wherein the voice commands carry adjustment instructions for nodes in the processing flow; the voice commands are intelligently parsed, and the graphical processing flow is adjusted to form an adjusted graphical processing flow.

[0226] In one implementation, the conversion module 702 can specifically invoke a three-layer compilation architecture, which includes a component semantic parsing layer, an intermediate representation layer, and a target code generation layer; by invoking the three-layer compilation architecture, the graphical processing flow is logically converted to obtain an executable script.

[0227] In one implementation, the conversion module 702 can specifically retrieve a pre-established mapping rule library between preset components and code; calculate the weight of the path on which the preset component depends through the mapping rule library; combine the weight of the path on which the preset component depends with the weight of the path and perform weight mutation detection based on the directed graph topology sorting; if the detection passes, convert the graphical processing flow into executable code through a dynamic template engine and output the executable script.

[0228] In one implementation, the prediction module 703 may specifically incorporate an AI engine and a low-code platform. The AI ​​engine receives execution logs through a message queue; the AI ​​engine analyzes the execution logs to obtain optimization suggestions for the executable script; the optimization suggestions for the executable script are pushed to the low-code platform; and the user performs optimization and confirmation operations on the executable script on the low-code platform.

[0229] In one embodiment, the prediction module 703 can specifically collect historical process execution logs, wherein the process execution logs include at least one of the following: execution time, error rate, and resource consumption; extract feature data of key features from the process execution logs, wherein the key features include at least one of the following: process complexity, API call frequency, and data size; train a preset prediction model using the feature data; and predict the optimal process parameters for the generated data processing stream using the trained prediction model, wherein the process parameters include at least one of the following: concurrency and timeout threshold.

[0230] In one implementation, training a preset prediction model using the feature data may include: constructing a four-dimensional indicator system, wherein the dimensions of the four-dimensional indicator system include: timeliness, resource consumption, anomaly correlation, and scene complexity; wherein the feature corresponding to timeliness is step delay rate, and the corresponding extraction method is sliding window statistics; the feature corresponding to resource consumption is CPU peak value, and the corresponding extraction method is monitoring; the feature corresponding to anomaly correlation is error propagation tree depth, and the corresponding extraction method is graph neural network; the feature corresponding to scene complexity is unstructured data processing density, and the corresponding extraction method is text vectorization and clustering; and establishing a preset prediction model using the four-dimensional indicator system, wherein the preset prediction model includes: a feature vector input layer, a multi-head attention layer, and a dual-branch output layer, wherein the two outputs of the dual-branch output layer are concurrency prediction and timeout threshold prediction.

[0231] In one implementation, the parsing module 704 can specifically invoke a multi-scene adapter, wherein the multi-scene adapter includes scene templates corresponding to each scene in multiple scenes, and each scene template includes: data conversion rules and a dedicated interface; obtain the scene identifier in the general task flow; match the scene template corresponding to the multi-scene adapter according to the scene identifier as the target template; convert the format of the general task flow into the task format required by the execution system corresponding to the target scene through the data conversion rules of the target template; after parsing, call the dedicated interface in the target template to transmit the converted task format to the execution system corresponding to the target scene.

[0232] In one implementation, the execution module 705 can specifically coordinate with the scheduling center to obtain the execution priority of the tasks corresponding to each target scenario; the scheduling center adopts a weighted round-robin method to execute tasks in descending order of priority according to the execution priority of the tasks corresponding to each target scenario; during the task execution process, if a task execution failure is detected and the number of automatic retries exceeds the preset number of executions, the task is transferred to a backup node for execution, and the status of each execution node is monitored in real time. If it is determined that there is a downtime execution node, the execution node is removed as a faulty node.

[0233] The embodiments of this application also provide a specific implementation of an electronic device capable of implementing all steps of the automatic task flow processing method in the above embodiments. The electronic device specifically includes: a processor, a memory, a communication interface, and a bus; wherein the processor, memory, and communication interface communicate with each other via the bus; the processor is used to call a computer program in the memory, and when the processor executes the computer program, it implements all steps of the automatic task flow processing method in the above embodiments. For example, when the processor executes the computer program, it implements the following steps:

[0234] Step 1: Obtain the user's drag-and-drop operations and parameter configurations for the preset components in the display interface, and generate a graphical processing flow based on the drag-and-drop operations and parameter configurations for the preset components. Each preset component supports parameter configuration.

[0235] Step 2: Perform logical transformation on the graphical processing flow to obtain an executable script;

[0236] Step 3: Predict user design intent for the generated executable script and generate optimization suggestions for the executable script to obtain a general task flow;

[0237] Step 4: Parse the general task flow according to the scene identifier in the general task flow to convert the general task flow into the task format required by the execution system corresponding to the target scene;

[0238] Step 5: Dynamically allocate and execute tasks according to priority and resource load based on the task format required by the execution system corresponding to the target scenario.

[0239] Embodiments of this application also provide a computer-readable storage medium capable of implementing all steps of the automatic task flow processing method in the above embodiments. The computer-readable storage medium stores a computer program that, when executed by a processor, implements all steps of the automatic task flow processing method in the above embodiments. For example, when the processor executes the computer program, it implements the following steps:

[0240] Step 1: Obtain the user's drag-and-drop operations and parameter configurations for the preset components in the display interface, and generate a graphical processing flow based on the drag-and-drop operations and parameter configurations for the preset components. Each preset component supports parameter configuration.

[0241] Step 2: Perform logical transformation on the graphical processing flow to obtain an executable script;

[0242] Step 3: Predict user design intent for the generated executable script and generate optimization suggestions for the executable script to obtain a general task flow;

[0243] Step 4: Parse the general task flow according to the scene identifier in the general task flow to convert the general task flow into the task format required by the execution system corresponding to the target scene;

[0244] Step 5: Dynamically allocate and execute tasks according to priority and resource load based on the task format required by the execution system corresponding to the target scenario.

[0245] As described above, this application embodiment generates a graphical processing flow based on the user's drag-and-drop operation and parameter configuration of preset components. Then, the graphical processing flow is logically transformed to obtain an executable script. Further, the generated executable script is used to predict the user's design intent and generate optimization suggestions for the executable script to obtain a general task flow. Then, the general task flow is parsed according to the scenario identifier in the general task flow to convert the general task flow into the task format required by the execution system corresponding to the target scenario. The task format required by the execution system corresponding to the target scenario is dynamically allocated and executed based on priority and resource load. The above solution solves the technical problems of low intelligence, lack of dynamic adaptability, and weak multimodal interaction support in existing RPA systems, and achieves the technical effect of improving the ability of unstructured data processing and dynamic decision-making, and realizing low-code development and rapid adaptation to multi-scenario requirements.

[0246] The user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, data stored, data displayed, etc.) involved in this application are all information and data authorized by the user or fully authorized by all parties. The collection, use and processing of the relevant data shall comply with relevant laws, regulations and standards, and corresponding operation entry points shall be provided for users to choose to authorize or refuse.

[0247] The various embodiments in this specification are described in a progressive manner. Similar or identical parts between embodiments can be referred to interchangeably. Each embodiment focuses on its differences from other embodiments. In particular, hardware + program embodiments are relatively simple in description because they are fundamentally similar to method embodiments; relevant parts can be referred to the descriptions in the method embodiments.

[0248] The foregoing has described specific embodiments of this specification. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recited in the claims may be performed in a different order than that shown in the embodiments and may still achieve the desired result. Furthermore, the processes depicted in the drawings do not necessarily require the specific or sequential order shown to achieve the desired result. In some embodiments, multitasking and parallel processing are possible or may be advantageous.

[0249] While this application provides the method operation steps as described in the embodiments or flowcharts, more or fewer operation steps may be included based on conventional or non-inventive labor. The order of steps listed in the embodiments is merely one possible execution order among many and does not represent the only execution order. In actual device or client product execution, the methods shown in the embodiments or drawings can be executed sequentially or in parallel (e.g., in a parallel processor or multi-threaded processing environment).

[0250] The systems, devices, modules, or units described in the above embodiments can be implemented by computer chips or entities, or by products with certain functions. A typical implementation device is a computer. Specifically, a computer can be, for example, a personal computer, a laptop computer, an in-vehicle human-machine interaction device, a cellular phone, a camera phone, a smartphone, a personal digital assistant, a media player, a navigation device, an email device, a game console, a tablet computer, a wearable device, or any combination of these devices.

[0251] While this specification provides method operation steps as described in the embodiments or flowcharts, more or fewer operation steps may be included based on conventional or non-inventive means. The order of steps listed in the embodiments is merely one possible execution order among many and does not represent the only execution order. In actual device or end product execution, the methods shown in the embodiments or drawings may be executed sequentially or in parallel (e.g., in a parallel processor or multi-threaded processing environment, or even a distributed data processing environment). The terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, product, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, product, or apparatus. Without further limitations, the presence of other identical or equivalent elements in the process, method, product, or apparatus that includes said elements is not excluded.

[0252] For ease of description, the above devices are described in terms of function, divided into various modules. Of course, in implementing the embodiments of this specification, the functions of each module can be implemented in one or more software and / or hardware components, or a module that performs the same function can be implemented by a combination of multiple sub-modules or sub-units. The device embodiments described above are merely illustrative. For example, the division of units is only a logical functional division; in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be through some interfaces, or indirect coupling or communication connection between devices or units, and may be electrical, mechanical, or other forms.

[0253] Those skilled in the art will also know that, besides implementing the controller using purely computer-readable program code, the same functions can be achieved by logically programming the method steps, making the controller function as logic gates, switches, application-specific integrated circuits (ASICs), programmable logic controllers (PLCs), and embedded microcontrollers. Therefore, such a controller can be considered a hardware component, and the devices within it used to implement various functions can also be considered structures within that hardware component. Alternatively, the devices used to implement various functions can be considered as both software modules implementing the method and structures within a hardware component.

[0254] This application is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of this application. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart... Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0255] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0256] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0257] In a typical configuration, a computing device includes one or more processors (CPU), input / output interfaces, network interfaces, and memory.

[0258] Memory may include non-persistent storage in computer-readable media, such as random access memory (RAM) and / or non-volatile memory, such as read-only memory (ROM) or flash RAM. Memory is an example of computer-readable media.

[0259] Computer-readable media includes both permanent and non-permanent, removable and non-removable media that can store information using any method or technology. Information can be computer-readable instructions, data structures, modules of programs, or other data. Examples of computer storage media include, but are not limited to, phase-change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technologies, CD-ROM, digital versatile optical disc (DVD) or other optical storage, magnetic tape, disk storage or other magnetic storage devices, or any other non-transferable medium that can be used to store information accessible by a computing device. As defined herein, computer-readable media does not include transient computer-readable media, such as modulated data signals and carrier waves.

[0260] Those skilled in the art will understand that the embodiments of this specification can be provided as methods, systems, or computer program products. Therefore, the embodiments of this specification can take the form of entirely hardware embodiments, entirely software embodiments, or embodiments combining software and hardware aspects. Furthermore, the embodiments of this specification can take the form of computer program products implemented on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0261] The embodiments described in this specification can be described in the general context of computer-executable instructions, such as program modules, that are executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, etc., that perform a specific task or implement a specific abstract data type. The embodiments of this specification can also be practiced in distributed computing environments where tasks are performed by remote processing devices connected via a communication network. In distributed computing environments, program modules can reside in local and remote computer storage media, including storage devices.

[0262] The various embodiments in this specification are described in a progressive manner. Similar or identical parts between embodiments can be referred to mutually. Each embodiment focuses on describing the differences from other embodiments. In particular, system embodiments are basically similar to method embodiments, so the description is relatively simple; relevant parts can be referred to the descriptions in the method embodiments. In the description of this specification, the terms "one embodiment," "some embodiments," "example," "specific example," or "some examples," etc., refer to specific features, structures, materials, or characteristics described in connection with that embodiment or example, which are included in at least one embodiment or example of the embodiments in this specification. In this specification, the illustrative expressions of the above terms do not necessarily refer to the same embodiment or example. Furthermore, the specific features, structures, materials, or characteristics described can be combined in any suitable manner in one or more embodiments or examples. Moreover, without contradiction, those skilled in the art can combine and integrate the different embodiments or examples described in this specification and the features of different embodiments or examples.

[0263] The above description is merely an embodiment of the present specification and is not intended to limit the embodiments of the present specification. For those skilled in the art, various modifications and variations can be made to the embodiments of the present specification. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principle of the embodiments of the present specification should be included within the scope of the claims of the embodiments of the present specification.

Claims

1. An automatic task flow processing method, characterized in that, The method includes: The system obtains the user's drag-and-drop operations and parameter configurations of preset components in the display interface, and generates a graphical processing flow based on the drag-and-drop operations and parameter configurations of the preset components. Each preset component supports parameter configuration. The graphical processing flow is logically transformed to obtain an executable script; Optimization suggestions are generated for the executable script to obtain a general task flow; The general task flow is parsed based on the scene identifier in the general task flow to convert the general task flow into the task format required by the execution system corresponding to the target scene; The task format required by the execution system corresponding to the target scenario is dynamically allocated and executed based on priority and resource load; The process of generating optimization suggestions for the executable script includes: the AI ​​engine receiving execution logs through a message queue; the AI ​​engine analyzing the execution logs to obtain optimization suggestions for the executable script; pushing the optimization suggestions for the executable script to a low-code platform; and the user performing optimization and confirmation operations on the executable script on the low-code platform. The process of parsing the general task flow based on the scene identifiers in the general task flow to convert it into a task format required by the execution system corresponding to the target scene includes: invoking a multi-scene adapter, wherein the multi-scene adapter includes scene templates corresponding to each of multiple scenes, and each scene template includes: data conversion rules and a dedicated interface; obtaining the scene identifiers in the general task flow; matching the scene identifiers to obtain the corresponding scene templates in the multi-scene adapter as the target template; converting the format of the general task flow into the task format required by the execution system corresponding to the target scene using the data conversion rules of the target template; and after parsing, calling the dedicated interface in the target template to transmit the converted task format to the execution system corresponding to the target scene.

2. The method according to claim 1, characterized in that, After obtaining the user's drag-and-drop operations and parameter configurations of preset components in the display interface, and generating a graphical processing flow based on the drag-and-drop operations and parameter configurations of the preset components, the process also includes: Receive user voice commands, wherein the voice commands carry instructions for adjusting nodes in the processing flow; The voice commands are intelligently parsed, and the graphical processing flow is adjusted to form an adjusted graphical processing flow.

3. The method according to claim 1, characterized in that, The graphical processing flow is logically transformed to obtain an executable script, including: The three-layer compilation architecture is invoked, wherein the three-layer compilation architecture includes: a component semantic parsing layer, an intermediate representation layer, and a target code generation layer; By invoking a three-tier compilation architecture, the graphical processing flow is logically transformed to obtain an executable script.

4. The method according to claim 1, characterized in that, The graphical processing flow is logically transformed to obtain an executable script, including: Retrieve a pre-established mapping rule library between pre-built components and code; The weights of the paths that the pre-built components depend on are calculated using the mapping rule base. By combining the weights of the paths on which the pre-built components depend, weight mutation detection is performed based on the topological sorting of the directed graph; If the test passes, the graphical processing flow is converted into executable code using a dynamic template engine, and an executable script is output.

5. The method according to claim 1, characterized in that, Optimization suggestions are generated for the executable script to obtain a general task flow, including: Collect historical process execution logs, wherein the process execution logs include at least one of the following: execution time, error rate, and resource consumption; Extract feature data of key features from the process execution log, wherein the key features include at least one of the following: process complexity, API call frequency, and data volume; The preset prediction model is trained using the feature data; The trained prediction model is used to predict the optimal process parameters of the generated executable script, wherein the process parameters include at least one of the following: concurrency and timeout threshold.

6. The method according to claim 5, characterized in that, Training a preset prediction model using the feature data includes: A four-dimensional indicator system is constructed, comprising the following dimensions: timeliness, resource consumption, anomaly correlation, and scenario complexity. Timeliness is characterized by step delay rate, extracted using sliding window statistics. Resource consumption is characterized by peak CPU usage, extracted using monitoring. Anomaly correlation is characterized by error propagation tree depth, extracted using graph neural networks. Scenario complexity is characterized by unstructured data processing density, extracted using text vectorization and clustering. A pre-defined prediction model is established using a four-dimensional indicator system. The pre-defined prediction model includes a feature vector input layer, a multi-head attention layer, and a dual-branch output layer. The two outputs of the dual-branch output layer are the concurrency prediction and the timeout threshold prediction.

7. The method according to any one of claims 1 to 6, characterized in that, Dynamic allocation and execution of tasks based on priority and resource load includes: The collaborative scheduling center obtains the execution priority of tasks corresponding to each target scenario; The scheduling center uses a weighted round-robin approach to execute tasks in descending order of priority according to the execution priority of the tasks corresponding to each target scenario. If a task fails during execution and the number of automatic retries exceeds the preset number of executions, the task will be transferred to a backup node for execution. The status of each execution node will be monitored in real time. If a failed execution node is identified, it will be removed as a faulty node.

8. An automatic task flow processing device, characterized in that, include: The acquisition module is used to acquire the user's drag-and-drop operations and parameter configurations of the preset components in the display interface, and generate a graphical processing flow based on the drag-and-drop operations and parameter configurations of the preset components. Each preset component supports parameter configuration. The conversion module is used to logically convert the graphical processing flow to obtain an executable script. The prediction module is used to generate optimization suggestions for the executable script to obtain a general task flow; The parsing module is used to parse the general task flow according to the scene identifier in the general task flow, so as to convert the general task flow into the task format required by the execution system corresponding to the target scene; The execution module is used to dynamically allocate and execute tasks according to priority and resource load, based on the task format required by the execution system corresponding to the target scenario. The process of generating optimization suggestions for the executable script includes: the AI ​​engine receiving execution logs through a message queue; the AI ​​engine analyzing the execution logs to obtain optimization suggestions for the executable script; pushing the optimization suggestions for the executable script to a low-code platform; and the user performing optimization and confirmation operations on the executable script on the low-code platform. The process of parsing the general task flow based on the scene identifiers in the general task flow to convert it into a task format required by the execution system corresponding to the target scene includes: invoking a multi-scene adapter, wherein the multi-scene adapter includes scene templates corresponding to each of multiple scenes, and each scene template includes: data conversion rules and a dedicated interface; obtaining the scene identifiers in the general task flow; matching the scene identifiers to obtain the corresponding scene templates in the multi-scene adapter as the target template; converting the format of the general task flow into the task format required by the execution system corresponding to the target scene using the data conversion rules of the target template; and after parsing, calling the dedicated interface in the target template to transmit the converted task format to the execution system corresponding to the target scene.

9. An electronic device comprising a processor and a memory for storing processor-executable instructions, characterized in that, When the processor executes the instructions, it implements the steps of the method according to any one of claims 1 to 7.

10. A computer-readable storage medium having a computer program / instructions stored thereon, characterized in that, When the computer program / instructions are executed by the processor, they implement the steps of the method according to any one of claims 1 to 7.

Images