Iterative task execution method and system based on dynamic feedback and causal fault tolerance

Abstract

The invention discloses an iterative task execution method and system based on dynamic feedback and causal fault tolerance, belongs to the technical field of artificial intelligence and data analysis, and remarkably improves the execution success rate and system robustness of a complex data analysis task by fusing multi-modal perception, dynamic feedback and causal reasoning. According to the method, the disassembling deviation caused by information splitting is avoided, the task complexity is quantified through the graph neural network, self-adaptive task disassembling is achieved, a dynamic feedback mechanism is combined, the task structure is corrected in real time in the execution process, and insertion, combination and sequence adjustment of subtasks are supported. A causal fault-tolerant strategy based on a historical failure trajectory is introduced, a high-risk path can be pre-judged, defensive operation can be automatically embedded, and error propagation is blocked. The whole process execution track is stored in a memory bank and is used for continuously optimizing the model and the strategy to form the closed-loop learning ability.

Description

Technical Field

[0001] This invention belongs to the field of artificial intelligence and data analysis technology, specifically relating to an iterative task execution method and system based on dynamic feedback and causal fault tolerance. Background Technology

[0002] In enterprise-level intelligent data analytics platforms, business users often propose complex, multi-stage data analysis tasks in natural language, such as "analyze the reasons for user churn in the past three months and propose actionable improvement suggestions." These tasks typically involve multiple interdependent sub-processes, including data cleaning, feature engineering, model training, attribution analysis, and strategy generation, and are characterized by cross-module nature, strong dependencies, and high semantic density. Although large language models have demonstrated significant capabilities in semantic understanding and process generation, existing systems still face several key bottlenecks in actual execution:

[0003] First, the initial task breakdown is susceptible to the ambiguity of natural language expression, causing the subtask structure to deviate from the actual requirements. For example, if the user does not explicitly mention "data quality check," the system may omit this crucial preliminary step, or misunderstand "making suggestions" as an independent action, ignoring its logical premise that it must rely on the results of attribution analysis, resulting in a broken task chain or disordered execution order. Existing methods mostly adopt static breakdown strategies, lacking a perception and feedback mechanism for intermediate results during execution, and cannot dynamically correct initial deviations.

[0004] Secondly, the input information exhibits multimodal heterogeneity, often accompanied by non-textual information such as data table examples, trend chart screenshots, and business process diagrams, in addition to natural language instructions. These modalities contain important contextual clues, but traditional methods can only process text input, making it difficult to achieve unified semantic modeling of multi-source information. This leads to a one-sided understanding of the task and further exacerbates the risk of decomposition errors.

[0005] Third, errors exhibit structural propagation characteristics within the task chain. Once a subtask fails due to input anomalies (such as missing fields or distribution offsets), its impact will spread along the dependency path, eventually causing the entire task to crash. Existing systems lack the ability to model the causal relationships of historical failure paths, cannot predict potential risks and embed defensive operations during the task planning phase, resulting in poor system robustness and weak self-healing capabilities.

[0006] Therefore, under the current technological background, there is an urgent need to build an intelligent task execution framework that integrates dynamic feedback correction, multimodal information fusion, and causal-driven fault tolerance in order to improve the automation level and execution success rate of complex data analysis tasks. Summary of the Invention

[0007] To address the shortcomings of the existing technologies, this application provides an iterative data analysis task execution method and system based on dynamic feedback and causal fault tolerance.

[0008] In its first aspect, this application proposes an iterative data analysis task execution method based on dynamic feedback and causal fault tolerance, comprising the following steps:

[0009] The system receives multimodal task information input by the user, including natural language instructions, table images, and trend graphs. A task semantic graph is constructed based on this information. The task semantic graph is then embedded and its complexity is quantified using a graph neural network and attention mechanism to generate an initial task decomposition scheme. During the execution of this initial scheme, intermediate results are monitored; if an anomaly is detected, a dynamic re-decomposition mechanism is triggered to update the task semantic graph and the task decomposition structure. An error propagation causal graph is constructed based on historical execution trajectories to identify high-frequency root cause paths and pre-set fault tolerance strategies. After task execution is complete, the entire process trajectory is encoded into a vector and stored in a memory bank for optimizing subsequent task decomposition and the fault tolerance strategies.

[0010] In some embodiments, the multimodal task information is uniformly mapped to the task semantic graph space through a dedicated adapter. The dedicated adapter is used for text parsing, table parsing, and image parsing. The text parsing includes extracting entities, operations, and constraints from natural language instructions. The table parsing includes recognizing table structure, field semantics, and relationships. The image parsing includes recognizing chart types, coordinate axes, and key inflection points.

[0011] In some embodiments, the nodes of the task semantic graph include operation nodes, data object nodes, and condition nodes, and the edges represent logical dependencies, data flow directions, or causal relationships.

[0012] In some embodiments, the complexity metric includes calculating a task complexity score based on features such as node embedding modulus, importance distribution entropy, average connection density, and longest path length.

[0013] In some embodiments, the dynamic re-disassembly mechanism includes:

[0014] The anomaly type, scope of impact, and original task description are jointly encoded into an enhanced Prompt.

[0015] Use a large language model for structural re-evaluation;

[0016] Insert or merge subtask nodes and update the task semantic graph.

[0017] In some embodiments, constructing an error propagation causal graph based on historical execution trajectories includes:

[0018] The PC algorithm is used to learn the causal structure from historical execution trajectories, and directional constraints and sparsity regularization are applied in conjunction with domain knowledge constraints. The PC algorithm includes the following steps:

[0019] Construct the initial undirected graph;

[0020] Perform conditional independence testing and pruning.

[0021] Identify V-structures and determine edge directions;

[0022] Estimate and sort the path propagation probabilities.

[0023] In some embodiments, the identification of high-frequency root cause paths and the preset fault tolerance strategy include:

[0024] The fault tolerance pre-set strategy is triggered in stages based on path confidence. When it is a high-risk path, defensive subtasks are automatically inserted and runtime assertions are set. When it is a medium-risk path, explicit reminders are added to the Prompt. When it is a low-risk path, it is only recorded to the monitoring log.

[0025] In some embodiments, the memory bank uses a vector database to store the task execution trajectory for continuous optimization of the graph neural network model, complexity scoring function, and error propagation causal graph structure.

[0026] Secondly, this application proposes an iterative data analysis task execution system based on dynamic feedback and causal fault tolerance, including a multimodal data acquisition module, a task decomposition module, a dynamic re-decomposition module, a fault tolerance strategy construction module, and an optimization iteration module;

[0027] The multimodal data acquisition module receives multimodal task information input by the user, including natural language instructions, table images, and trend graphs, and constructs a task semantic graph based on the multimodal task information. The task decomposition module embeds and quantifies the complexity of the task semantic graph using graph neural networks and attention mechanisms to generate an initial task decomposition scheme. The dynamic re-decomposition module monitors intermediate results during the execution of the initial task decomposition scheme. If an anomaly is detected, a dynamic re-decomposition mechanism is triggered to update the task semantic graph and the task decomposition structure. The fault tolerance strategy construction module constructs an error propagation causal graph based on historical execution trajectories, identifies high-frequency root cause paths, and presets fault tolerance strategies. The optimization iteration module encodes the entire process trajectory into a vector and stores it in a memory bank after task execution is completed, for optimizing subsequent task decomposition and the fault tolerance strategy.

[0028] Thirdly, this application proposes a computer-readable storage medium storing a computer program that, when executed by a processor, implements the steps of the method described above.

[0029] The beneficial effects of this invention are:

[0030] By integrating multimodal perception, dynamic feedback, and causal reasoning, the system significantly improves the success rate and robustness of complex data analysis tasks, avoiding decomposition biases caused by fragmented information. It quantifies task complexity through graph neural networks, enabling adaptive task decomposition, and combines a dynamic feedback mechanism to correct the task structure in real time during execution, supporting the insertion, merging, and reordering of subtasks. A causal fault-tolerance strategy based on historical failure trajectories is introduced, which can predict high-risk paths and automatically embed defensive operations to block error propagation. The entire execution trajectory is stored in a memory bank for continuous optimization of the model and strategy, forming a closed-loop learning capability. Attached Figure Description

[0031] Figure 1 This is the overall flowchart of the present invention.

[0032] Figure 2 This is a system principle block diagram of the present invention. Detailed Implementation

[0033] Exemplary embodiments of the invention will now be described in more detail with reference to the accompanying drawings. While exemplary embodiments of the invention are shown in the drawings, it should be understood that the invention may be implemented in various forms and should not be limited to the embodiments set forth herein; rather, these embodiments are provided so that a more thorough understanding of the invention can be achieved and that the full scope of the invention can be conveyed to those skilled in the art.

[0034] Firstly, this application proposes an iterative data analysis task execution method based on dynamic feedback and causal fault tolerance, such as... Figure 1 As shown, it includes the following steps:

[0035] S100: Receive multimodal task information input by the user, the multimodal task information including natural language instructions, table images, and trend charts, and construct a task semantic graph based on the multimodal task information; in some embodiments, the multimodal task information is uniformly mapped to the task semantic graph space through a dedicated adapter, the dedicated adapter being used for text parsing, table parsing, and image parsing, the text parsing including extracting entities, operations, and constraints from natural language instructions, the table parsing including recognizing table structure, field semantics, and relationships, and the image parsing including recognizing chart types, coordinate axes, and key inflection points.

[0036] This solution designs a dedicated adapter for text, tables, and images to achieve unified semantic modeling of heterogeneous inputs. The dedicated adapter consists of a large language model, a visual-language multimodal model, a chart classification model, a chart OCR model, and a time series analysis model. The large language model uses a designed prompting engineering to structurally parse user commands. The visual-language multimodal model is used for document and understanding, analyzing image-formatted tables and restoring their structured and semantic information. The chart classification model, chart OCR model, and time series analysis model work collaboratively, first determining the image type, identifying and extracting text elements from the chart, including titles, axis labels, legends, and data point labels. For charts such as line charts, computer vision technology is used to extract the coordinate values ​​of data points and convert them into numerical time series data. The time series data is smoothed and abrupt change points are detected, identifying key information such as "inflection points" and "peaks," and the extracted information is combined into natural language descriptions or structured conditions.

[0037] In some embodiments, the nodes of the task semantic graph include operation nodes, data object nodes, and condition nodes, and the edges represent logical dependencies, data flow directions, or causal relationships.

[0038] Taking the typical task of "analyzing the reasons for user churn in the past three months and proposing feasible improvement suggestions" as an example, users usually submit supplementary materials such as screenshots of sample data tables and historical churn rate trend charts, in addition to submitting natural language instructions. These non-text modalities contain key contextual clues: such as field naming conventions ("last_login_time" vs "recent_active_dt"), the churn inflection point time (a sharp increase in February in the trend chart), and abnormal fluctuation ranges, which are crucial for accurately understanding the task intent. First, each type of input is processed separately through a dedicated adapter. For natural language instructions, a large language model is invoked for semantic parsing to extract core entities (such as "user churn", "behavior log"), operation verbs ("analyze", "build", "propose"), and constraints ("the past three months", "feasible"). For table screenshots, a visual document understanding model such as LayoutLMv3 or Donut is used to identify the table structure, extract field names, sample values, data types, and infer potential primary and foreign key relationships; at the same time, combined with OCR and semantic matching technologies, the fields are mapped to a general ontology space (such as "churn_flag" ≈ "is_lost"). For trend charts, image classification and curve parsing models (such as ChartOCR+TimeSeriesNet) are used to identify the chart type (line chart), the meaning of the axes (X-axis for time, Y-axis for churn rate), key inflection points (e.g., a peak on February 15, 2024), and their possible causes ("post-Spring Festival work resumption slump"). Subsequently, the three types of modal information are uniformly mapped to a shared task semantic graph space. , where the node set It includes operation nodes (such as "data cleaning", "feature engineering", "model training"), data object nodes (such as "user behavior logs", "churn tag table", "trend chart"), and condition nodes (such as "time window: 2024Q1"). Edge set This represents logical dependencies, data flow, or causal relationships. The specific fusion strategy is as follows: Text parsing results generate the main workflow chain: data cleaning - feature engineering - model training - attribution analysis - strategy generation; the table adapter output is injected into the graph as a data source node, and dependency edges such as "data cleaning ← user behavior logs" are established; the inflection point information obtained from image parsing is transformed into the condition node "There is a significant increase in churn (2024-02)," and connected to the "attribution analysis" node through causal edges, indicating that the driving factors for this period need to be analyzed in detail; the field semantic alignment results are used to enhance node attributes, such as adding a candidate feature list to the "feature engineering" node: ["login_freq", "stay_duration", "click_count"]. The final initial task semantic graph is formed. It not only covers the explicit structure of language instructions, but also integrates the implicit context in multimodal input, significantly improving the completeness and accuracy of task understanding, and providing a high-fidelity semantic foundation for subsequent dynamic decomposition and fault-tolerant pre-configuration.

[0039] S200: Based on graph neural networks and attention mechanisms, the semantic graph of the task is embedded and its complexity is quantified to generate an initial task decomposition scheme;

[0040] In constructing the task semantic graph Building upon this foundation, we further evaluate the inherent complexity of the task to achieve granular adaptive task decomposition. Traditional methods rely on fixed templates or heuristic rules, making it difficult to handle semantic fluctuations in the task. This approach, however, introduces for the first time a complex quantification model jointly driven by graph neural networks and attention mechanisms, enabling computable modeling of task structural features. The GraphSAGE architecture is used to encode the task semantic graph: each node... Initialize the BERT embedding to its text description Then the representation is updated through K-level aggregation operations:

[0041]

[0042] in, For nodes The neighborhood group, , For trainable parameters, This represents mean pooling. After K=3 layers of propagation, the final node embedding is obtained. The embedding representation of each node is updated through a graph neural network. Specifically, for each node, its embedding representation from the previous layer is aggregated with the embedding representations of all its neighbors (using mean pooling), and then a trainable linear transformation and activation function are applied to obtain the node embedding representation of the current layer. This process is iterated over typically three layers to capture the local structure and semantic information of the graph.

[0043]

[0044] in, For graph-level global representation, To query the key transformation matrix, For attention weight vectors, This mechanism represents vector concatenation. It automatically identifies key decision nodes (such as "model training" and "policy generation"), assigns them higher weights, and uses an attention mechanism to calculate the importance weight of each node. First, the embedding representation of each node is concatenated with the global representation of the graph (obtained through the mean or pooling of all node embeddings), and then processed through a trainable linear transformation and a non-linear activation function. Next, a score is calculated using a query vector and normalized using a softmax function to obtain the attention weight of each node. This weight reflects the semantic importance of the node in the task and is used for subsequent complexity metric. In some embodiments, the complexity metric includes calculating a task complexity score based on features such as node embedding modulus, importance distribution entropy, average connection density, and longest path length.

[0045] By combining topological and semantic features, a task complexity scoring function is constructed:

[0046]

[0047] in, The module length represents the node embedding, reflecting semantic richness; a larger module length indicates more complex semantics. The entropy represents the importance distribution, calculated based on attention weights. A higher entropy value indicates that the key points of the task are more dispersed, and the greater the coordination difficulty. This represents the average connectivity density, measuring the density of edges in a graph, i.e., the ratio of the actual number of edges to the maximum possible number of edges. A higher value indicates a stronger coupling between tasks. This represents the length of the longest path in the graph, expressed in terms of the number of edges, reflecting the depth of the task flow.

[0048] These features are weighted and combined, with the weight coefficients determined through regression training based on historical task execution success rates, ultimately yielding a task complexity score for adaptive task decomposition. The weight coefficients are determined through regression training based on historical task success rates. Taking the current "user churn analysis" task as an example, the following values ​​are calculated: average embedding modulus length: 1.78; weight entropy: 1.49; connection density: 0.83; longest path: 4. After normalization and weighting, the results are: This is considered medium to high complexity. Based on this, a table is consulted to recommend the optimal number of subtasks. The system generates a hierarchical breakdown prompt: "Please break down this task into 5 logically coherent and independently executable subtasks. Each subtask should include clearly defined inputs, operations, and outputs. Reference workflow: Data preparation - Feature construction - Model training - Attribution analysis - Policy output."

[0049] Based on this, LLM outputs an initial disassembly plan:

[0050] 1. Clean user behavior logs and extract activity and interaction features;

[0051] 2. Construct an XGBoost classification model to predict churn probability;

[0052] 3. Calculate feature importance and identify dominant factors;

[0053] 4. Analyze the business background of the churn inflection point in February;

[0054] 5. Generate three actionable operational intervention recommendations.

[0055] The task decomposition has initially covered the key elements of multimodal input, but execution deviations may still exist, requiring continuous optimization through a dynamic feedback mechanism. S300: During the execution of the initial task decomposition scheme, intermediate results are monitored. If an anomaly is detected, a dynamic re-decomposition mechanism is triggered to update the task semantic graph and task decomposition structure. In some embodiments, the dynamic re-decomposition mechanism includes:

[0056] The anomaly type, scope of impact, and original task description are jointly encoded into an enhanced Prompt.

[0057] Use a large language model for structural re-evaluation;

[0058] Insert or merge subtask nodes and update the task semantic graph.

[0059] To address the structural distortion caused by semantic ambiguity or lack of context in the initial task decomposition, this solution constructs a dynamic feedback-based decomposition correction mechanism based on intermediate result awareness to achieve iterative optimization of the task structure. This mechanism monitors output quality in real time during subtask execution, triggering a re-decomposition process upon detecting anomalies, forming a closed-loop control of "execution-feedback-reconstruction." For example, if the following is detected: Field missing rate: login_freq missing 42%, last_page completeness only 58%, data distribution offset: stay_duration average 12.3 seconds, significantly lower than the historical average (89 seconds), timestamp anomaly: 18% of records have timestamps earlier than the user registration time. Based on preset thresholds (e.g., field missing > 30%, distribution offset > 2σ), a serious data quality problem is identified, requiring the insertion of a "data quality diagnosis" subtask. At this point, the re-decomposition mechanism is activated: 1. The original task description... Initial task semantic graph Current execution status (Including anomaly type and impact scope) Jointly encoded as an enhanced Prompt; 2. Injected instruction: "Data integrity is severely insufficient. Please re-evaluate the task structure and consider whether to add a preprocessing step"; 3. Call LLM for structure re-evaluation. The large model response is as follows: "It is recommended to add a 'Data Quality Assessment and Repair' sub-task before 'Data Cleaning,' including: missing field diagnosis, outlier cleaning, and time consistency verification, and decide whether to supplement external data sources based on the results." Update the task semantic graph accordingly. Insert a new node The task was renamed "Data Quality Diagnosis," and its dependencies were adjusted to: Data Quality Diagnosis - Data Cleaning - Feature Engineering. Simultaneously, the original task numbers 2-5 were sequentially renumbered to ensure logical continuity. The task structure was consistently aligned with the actual execution status, effectively correcting initial misunderstandings.

[0060] S400: Constructs an error propagation cause-effect graph based on historical execution trajectories, identifies high-frequency root cause paths, and pre-configures fault tolerance strategies;

[0061] In some embodiments, constructing an error propagation causal graph based on historical execution trajectories includes:

[0062] The PC algorithm is used to learn the causal structure from historical execution trajectories, and directional constraints and sparsity regularization are applied in conjunction with domain knowledge constraints. The PC algorithm includes the following steps:

[0063] Construct the initial undirected graph;

[0064] Perform conditional independence testing and pruning.

[0065] Identify V-structures and determine edge directions;

[0066] Estimate and sort the path propagation probabilities.

[0067] In some embodiments, the identification of high-frequency root cause paths and the preset fault tolerance strategy include:

[0068] The fault tolerance pre-set strategy is triggered in stages based on path confidence. When it is a high-risk path, defensive subtasks are automatically inserted and runtime assertions are set. When it is a medium-risk path, explicit reminders are added to the Prompt. When it is a low-risk path, it is only recorded to the monitoring log.

[0069] To address the structural propagation of errors within the task chain, defensive operations are proactively embedded during the task decomposition phase to block potential failure paths. This includes a historical execution trajectory database that stores the complete context of past tasks: input, task semantic graph, decomposition process, execution logs, error codes, and remedial actions. By performing causal chain mining on failure cases, an "error propagation causal graph" is constructed. , where nodes Indicate the error type (e.g., "field missing", "model does not converge", "attribution has no significant features"), edge It represents causal relationships (such as "missing fields lead to model training failure" or "lack of standardization leads to distortion of feature importance"), combines domain knowledge constraints, learns causal structures from historical data, and estimates the propagation probability of each path. .

[0070] For example, the path "Handling missing values ​​- Model training failed" was found: The path is "Unidentified Inflection Point - Attribution Bias": In the current task decomposition phase, the initial task semantic graph will be... With cause-effect diagram Alignment identifies potential risk paths. For example, if the current task involves fields with high missing values, and a "field missing - model failure" path is matched with a confidence level > 0.7, a fault-tolerance pre-set strategy is triggered: 1. Automatically insert a defensive subtask, "Missing Value Diagnosis and Imputation," into the task semantic graph and configure a default strategy (such as MICE imputation + labeling mechanism); 2. Add a runtime assertion to the "Model Training" node: if the input feature missing rate > 10%, interrupt execution and issue an alarm; 3. Add a constraint to the Prompt: "Data quality assessment must be completed before entering the modeling stage." In summary, this mechanism realizes the transformation from "passive repair" to "proactive prevention." S500: After the task execution is completed, the entire process trajectory is encoded into a vector and stored in the memory bank for optimizing subsequent task decomposition and the aforementioned fault-tolerance strategy.

[0071] In some embodiments, the memory bank uses a vector database to store the task execution trajectory for continuous optimization of the graph neural network model, complexity scoring function, and error propagation causal graph structure.

[0072] After a task is successfully executed, the entire trajectory (including multimodal input, graph evolution, abnormal events, and repair actions) is encoded as a vector and written into the memory bank to optimize future causal models and complexity scorers.

[0073] Furthermore, taking a large internet company's data analysis platform receiving high semantic density tasks daily, such as "analyzing the reasons for user churn in the past three months and proposing actionable improvement suggestions," as an implementation scenario, this technical solution is combined with its end-to-end implementation process in the "user churn analysis" task:

[0074] I. Multimodal Task Adaptation and Task Semantic Graph Construction

[0075] When receiving composite input from a user: The text instruction is: "Please analyze the reasons for user churn in the past three months, build a predictive model based on behavior logs, and provide three actionable operational improvement suggestions." A screenshot of the table shows a sample data table containing the fields user_id, last_login_time, churn_flag, and click_count; a trend graph shows the monthly churn rate changes from January to March 2024, with a significant upward inflection point on February 15th. Dedicated adapters handle the three types of input separately.

[0076] 1. Text parsing:

[0077] The Large Language Model (LLM) is invoked to perform semantic parsing of natural language instructions, extracting: core entities: user churn, behavior logs, and operational suggestions; action verbs: analyze, construct, and propose constraints: the last three months and executable data; data cleaning → feature engineering → model training → attribution analysis → strategy generation.

[0078] 2. Table Structure Understanding: The Donut visual document understanding model is used to parse the table screenshot: OCR recognition of field names: user_id, last_login_time, churn_flag, click_count

[0079] The primary key is inferred to be user_id, and the label field is churn_flag. Using semantic matching technology, last_login_time is mapped to the concept of "recent active time" in the general ontology space, where churn_flag is approximately equivalent to "whether the user has churned." 3. Image trend analysis: The trend chart is analyzed using a ChartOCR+TimeSeriesNet joint model.

[0080] Chart type identification: Line chart

[0081] Analysis of the coordinate axes: The X-axis represents time (January 2024 to March 2024), and the Y-axis represents the "monthly churn rate";

[0082] The key inflection point was detected: the churn rate surged from 1.8% to 4.6% on February 15, 2024; based on external knowledge base, the possible cause was speculated to be: "The low return-to-work period after the Spring Festival led to a decline in user activity";

[0083] This information was transformed into a condition node: "There is a significant upward trend in churn (2024-02-15)", and marked as requiring key attribution.

[0084] 4. Task semantic graph construction: Integrate the above three types of information into a shared task semantic graph space. :

[0085] Node set This includes operational nodes: data cleaning, feature engineering, model training, attribution analysis, and strategy generation; data object nodes: user behavior logs, churn tag table, and trend chart; and condition nodes: time window: Q1 2024, with a significant increase in churn (February 15, 2024).

[0086] Edge set This includes data dependencies: user behavior logs - data cleaning, churn label table - model training; logical flow: data cleaning - feature engineering - model training - attribution analysis - strategy generation; causal indication: existence of a significant churn increase - attribution analysis (high-weight edge).

[0087] Node attribute enhancements: Add a candidate feature list to feature engineering: ["login_freq","stay_duration","click_count"]; Add a focus time period to attribution analysis: ["2024-02-10","2024-02-20"];

[0088] Task semantic graph It not only covers the explicit flow of language instructions, but also incorporates key contexts such as table field naming conventions and hidden abnormal fluctuations in images, significantly improving the completeness of task understanding.

[0089] II. Task Complexity Measurement and Adaptive Initial Decomposition Based on Graph Embedding

[0090] Based on construction This involves launching a complex metric model driven by graph embedding to achieve adaptive recommendation at the task decomposition granularity, including the following: 1. Graph neural network encoding:

[0091] The GraphSAGE architecture is used to learn node representations for the task semantic graph: BERT embeddings are initialized with their textual descriptions. The node representation is updated through K=3 layer aggregation:

[0092]

[0093] in, Represents a node The set of neighbors; Indicates the first Layer trainable parameters; This represents the mean pooling operation; the output dimension is... After three layers of propagation, the final node embedding is obtained. .

[0094] 2. Attention Mechanism for Calculating Importance Weights: A multi-head attention mechanism is introduced to calculate the semantic importance of each node in the task.

[0095]

[0096] in: For graph-level global representation; To query the key transformation matrix, Represents the attention weight vector; This represents a vector concatenation operation. This mechanism automatically identifies key decision nodes, such as "model training" and "policy generation," and achieves high performance. .

[0097] 3. Task complexity score calculation: Construct a comprehensive scoring function:

[0098]

[0099] The parameters are explained below: The module length of a node embedding reflects its semantic richness. For example, "model training" has a relatively large module length because it involves deep semantics such as algorithm selection and parameter tuning. Entropy represents the distribution of importance; the higher the entropy, the more dispersed the key points of the task are, and the greater the difficulty of coordination. This represents the average connection density, measuring the strength of task coupling. In this example... ,have to ; This represents the length (number of edges) of the longest path in the graph. In this example, the path consists of four hops: data cleaning, feature engineering, model training, attribution analysis, and policy generation. The weight coefficients are determined through regression training based on historical task success rates.

[0100] Substituting the actual values, we get: average embedding modulus: 1.78; weight entropy: 1.49; connection density: 1.125; longest path: 4; after normalization and weighted calculation, we get:

[0101] From the table: This is a highly complex task, and it is recommended to break it down into... Sub-tasks.

[0102] 4. Initial task breakdown:

[0103] Based on this, the generated prompt is sent to the LLM: "Please break down this task into 5 logically coherent and independently executable subtasks. Each subtask should contain clearly defined inputs, operations, and outputs. Reference workflow: Data preparation → Feature construction → Model training → Attribution analysis → Policy output." The LLM outputs the initial breakdown scheme:

[0104] 1. Clean user behavior logs and extract activity and interaction features;

[0105] 2. Construct an XGBoost classification model to predict churn probability;

[0106] 3. Calculate feature importance and identify dominant factors;

[0107] 4. Analyze the business background of the churn inflection point in February;

[0108] 5. Generate three actionable operational intervention recommendations.

[0109] This breakdown has initially covered the key elements of multimodal input, but execution deviations may still exist, requiring continuous optimization through a dynamic feedback mechanism.

[0110] III. Dynamic Feedback-Based Decomposition and Correction Mechanism During Execution

[0111] In one embodiment, subtask 1, "Cleaning User Behavior Logs," is executed. After calling the data processing engine, intermediate result metadata is returned: Field missing rate: 42% of login_freq data is missing, and only 58% of last_page data is complete; Data distribution offset: the average stay_duration is 12.3 seconds, significantly lower than the historical average (89 seconds); Timestamp anomalies: 18% of the recorded timestamps are earlier than the user's registration time. Based on preset rules, it is determined that: field missing rates greater than 30% indicate serious data quality issues; distribution offset greater than 2σ indicates data collection anomalies; and timestamp logical errors greater than 10% indicate questionable data source reliability.

[0112] Overall assessment: The current data quality does not meet the modeling requirements, and a preprocessing step needs to be added.

[0113] (1) Triggering the re-disassembly mechanism:

[0114] Enhanced Prompt: "Original Task: Analyze the reasons for user churn and propose improvement suggestions; Initial Breakdown: 5 sub-tasks; Current Execution Status: During the 'data cleaning' phase, a field missing rate of up to 42% was found, the data distribution was severely skewed, and there were logical errors in the timestamps; Problem: The data integrity is seriously insufficient, which may lead to the failure of subsequent model training; Instructions: Please re-evaluate the task structure and consider whether it is necessary to add a data quality diagnosis and repair step."

[0115] When calling LLM for structural re-evaluation, the response is as follows: "It is recommended to add a 'Data Quality Diagnosis and Repair' subtask before 'Data Cleaning', including: missing field analysis, outlier cleaning, and time consistency verification, and decide whether to supplement external data sources or adjust feature definitions based on the results."

[0116] (2) Task semantic graph update

[0117] Based on this, the task semantic graph is updated as follows: Insert a new node "Data Quality Diagnosis and Repair"; Adjust dependencies: Data Quality Diagnosis and Repair - Data Cleaning - Feature Engineering; While renumbering the original tasks 2-5, check the relevance of subsequent tasks. It was found that the results of "Feature Importance Analysis" and "February Inflection Point Attribution" highly overlapped (similarity greater than 80%), triggering the merging mechanism to merge the two into "Multi-Dimensional Attribution Analysis" to reduce redundant calculations.

[0118] The final disassembly and adjustment were as follows:

[0119] 1. Data quality diagnosis and repair; 2. Clean user behavior logs and extract features; 3. Build an XGBoost model to predict churn probability; 4. Multi-dimensional attribution analysis (integrating feature importance and time inflection point); 5. Generate three actionable operational suggestions.

[0120] This dynamic correction process supports up to two iterations of refactoring, ensuring that the task structure is always aligned with the actual execution state.

[0121] IV. Fault Tolerance Strategy Pre-configuration and Error Propagation Blocking Mechanism Based on Causal Reasoning

[0122] Specifically, after the task is broken down but before execution, a causal reasoning module based on historical failure trajectories is activated to proactively pre-configure fault tolerance strategies.

[0123] (1) Constructing a cause-effect graph of error propagation

[0124] Maintain a historical execution trajectory database to store the complete context of past tasks. Construct an "error propagation causal graph" by mining the causal chains of failure cases. :node Error types, such as "field missing", "model does not converge", "attribution has no significant features", "policy is not executable" Causal relationships, such as "missing fields correspond to model training failure" or "unidentified inflection points correspond to attribution bias".

[0125] This study employs a PC algorithm combined with domain knowledge constraints to learn causal structures from historical data and estimate propagation probabilities. Specifically, it extracts failure cases from a historical execution trajectory database and uses the PC algorithm to learn a "causal graph of error propagation". It identifies high-frequency root cause paths and their propagation probabilities; during the task decomposition phase, if the confidence level of a risk path exceeds a set threshold, it automatically pre-sets defensive sub-tasks and runtime assertions to block the propagation of potential faults.

[0126] The specific implementation steps of the PC algorithm include: constructing an interpretable "error propagation causal graph". This scheme employs a PC algorithm to learn causal structure from a historical execution trajectory database. Based on a constrained causal discovery framework, the algorithm progressively constructs a directed acyclic graph (DAG) through a series of conditional independence tests, accurately depicting the causal direction between the root cause of the error and its propagation path. The specific implementation steps are as follows:

[0127] Step 1: Construct the initial undirected graph: This includes various observable error nodes (such as "missing fields", "data distribution offset", "model non-convergence", "attribution bias", "policy non-executability", etc.). Initialize a fully connected undirected graph with all variables as nodes. This indicates that there may be a correlation between any two errors.

[0128] Step Two: Perform Conditional Independence Test and Edge Pruning: Use the KCI method to perform the conditional independence test, which is suitable for nonlinear and non-Gaussian distributed erroneous data features. For each pair of adjacent nodes... and Test sequentially on condition sets of different sizes. hour To determine if the hypothesis is true, calculate the p-value using the GP-CIT or KCI test. If the p-value is greater than the significance level... If the condition is met, then the independence assumption is rejected and the edge is retained; otherwise, the edge is deleted. (Condition set) The size of the neighborhood starts from 0 and increases (i.e., zero-order, first-order, second-order... neighborhood) until it can no longer be pruned.

[0129] Step 3: Determine the directionality of the undirected skeleton: Identification rules determine the direction of some edges: if triples exist ,and and Independent without any conditions, but under control If it is no longer independent, then determine For collision nodes, mark as Then, based on the acyclic constraint of the DAG, the known directions are propagated to eliminate contradictions, ultimately yielding a complete directed causal graph. .

[0130] Step 4: Causality Strength Quantification and Path Confidence Estimation: Based on historical data, for each causal edge... Perform Bayesian network parameter learning to estimate conditional probabilities Combining path length and the transitivity of intermediate nodes, the propagation probability of the composite path is calculated using the path weight product method: All paths are sorted in descending order of propagation probability to form a list of high-frequency risk paths for subsequent fault tolerance pre-configuration.

[0131] Constraints of the PC algorithm: To ensure the neighborhood rationality and computational feasibility of the cause-effect graph, this scheme introduces the following four types of constraints:

[0132] Condition 1: Domain knowledge prior constraint. Before the PC algorithm is executed, a causal direction prior matrix is ​​constructed. ,in Indicates permission , This indicates a prohibition. This indicates an unknown value. This matrix is ​​used to guide the V-structure identification and directional propagation process, avoiding the generation of reverse causality that violates business logic (such as "model failure corresponds to missing data").

[0133] Condition 2: Temporal order constraint, requiring causal edges to conform to temporal sequence. For example, a causal path is only allowed if "field missing" occurs before "model training". By analyzing the event sequence in historical trajectories, a temporal reachability matrix is ​​automatically constructed to filter out potential edges that violate temporal logic. Condition 3: Sparsity regularization, degree This means that each faulty node has at most three direct predecessors or successors. Furthermore, Bonferroni correction is used in the conditional independence test, and the significance threshold is adjusted to [value missing]. ,in To verify the total number and control the overall Type I error rate, Condition 4: Interpretive pruning is implemented by removing historical paths with fewer than 5 samples to ensure that the cause-effect graph focuses on high-frequency, high-impact failure modes, thereby improving the practicality of subsequent fault-tolerance strategies.

[0134] Confidence threshold setting: To achieve accurate risk prediction and defense triggering, this solution designs a tiered confidence threshold mechanism, based on the propagation probability of causal paths. The strength of fault tolerance measures is determined by pre-defined fault tolerance strategies, including: high-risk paths, when... Time-sensitive: Automatically insert defensive subtasks (such as "data quality diagnosis") and configure runtime assertions to forcibly interrupt subsequent execution once the preconditions are detected; medium-risk paths, when When: Add explicit reminders in the Prompt, such as "Please check the completeness of input fields to avoid model failure due to missing information"; for low-risk paths, when Time: Only recorded in the monitoring log for manual review and model iteration optimization.

[0135] Secondly, this application proposes an iterative data analysis task execution system based on dynamic feedback and causal fault tolerance, such as... Figure 2 As shown, it includes a multimodal data acquisition module, a task decomposition module, a dynamic re-decomposition module, a fault tolerance strategy construction module, and an optimization iteration module;

[0136] The multimodal data acquisition module receives multimodal task information input by the user, including natural language instructions, table images, and trend graphs, and constructs a task semantic graph based on the multimodal task information. The task decomposition module embeds and quantifies the complexity of the task semantic graph using graph neural networks and attention mechanisms to generate an initial task decomposition scheme. The dynamic re-decomposition module monitors intermediate results during the execution of the initial task decomposition scheme. If an anomaly is detected, a dynamic re-decomposition mechanism is triggered to update the task semantic graph and the task decomposition structure. The fault tolerance strategy construction module constructs an error propagation causal graph based on historical execution trajectories, identifies high-frequency root cause paths, and presets fault tolerance strategies. The optimization iteration module encodes the entire process trajectory into a vector and stores it in a memory bank after task execution is completed, for optimizing subsequent task decomposition and the fault tolerance strategy.

[0137] Thirdly, this application proposes a computer-readable storage medium storing a computer program that, when executed by a processor, implements the steps of the method described above.

[0138] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the above-described division of functional units and modules is merely an example. In practical applications, the above functions can be assigned to different functional units and modules as needed, that is, the internal structure of the device can be divided into different functional units or modules to complete all or part of the functions described above. The functional units and modules in the embodiments can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit. Furthermore, the specific names of the functional units and modules are only for easy differentiation and are not intended to limit the scope of protection of this application. The specific working process of the units and modules in the above system can be referred to the corresponding process in the foregoing method embodiments, and will not be repeated here.

[0139] In the above embodiments, the descriptions of each embodiment have different focuses. For parts that are not described in detail or recorded in a certain embodiment, please refer to the relevant descriptions of other embodiments.

[0140] Those skilled in the art will recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this disclosure.

[0141] In the embodiments provided in this disclosure, it should be understood that the disclosed apparatus / computer devices and methods can be implemented in other ways. For example, the apparatus / computer device embodiments described above are merely illustrative. For instance, the division of modules or units is only a logical functional division, and in actual implementation, there may be other division methods. Multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the mutual coupling or direct coupling or communication connection shown or discussed may be through some interfaces, and the indirect coupling or communication connection between apparatuses or units may be electrical, mechanical, or other forms.

[0142] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0143] Furthermore, the functional units in the various embodiments of this disclosure can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit.

[0144] If an integrated module / unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, all or part of the processes in the methods of the above embodiments can also be implemented by a computer program instructing related hardware. The computer program can be stored in a computer-readable storage medium, and when executed by a processor, it can implement the steps of the various method embodiments described above. The computer program may include computer program code, which can be in the form of source code, object code, executable files, or certain intermediate forms. A computer-readable medium may include: any entity or device capable of carrying computer program code, recording media, USB flash drives, portable hard drives, magnetic disks, optical disks, computer memory, read-only memory (ROM), random access memory (RAM), electrical carrier signals, telecommunication signals, and software distribution media, etc. It should be noted that the content included in a computer-readable medium may be appropriately added to or subtracted according to the requirements of legislation and patent practice in a jurisdiction. For example, in some jurisdictions, according to legislation and patent practice, computer-readable media may not include electrical carrier signals and telecommunication signals.

[0145] The above are merely preferred embodiments of the present invention. It should be noted that any modifications and improvements made by those skilled in the art without departing from the present technical solution should also be considered to fall within the scope of protection claimed by the present solution.

Claims

1. An iterative data analysis task execution method based on dynamic feedback and causal fault tolerance, characterized by: Includes the following steps: Receive multimodal task information input by the user, the multimodal task information including natural language instructions, table images and trend graphs, and construct a task semantic graph based on the multimodal task information; Based on graph neural networks and attention mechanisms, the semantic graph of the task is embedded and its complexity is quantified to generate an initial task decomposition scheme. During the execution of the initial task decomposition scheme, intermediate results are monitored. If an anomaly is detected, a dynamic re-decomposition mechanism is triggered to update the task semantic graph and task decomposition structure. Based on historical execution trajectories, construct error propagation cause-effect graphs to identify high-frequency root cause paths and pre-configure fault tolerance strategies; After the task is completed, the entire trajectory is encoded into a vector and stored in a memory bank for use in optimizing subsequent task decomposition and the aforementioned fault tolerance strategy.

2. The method according to claim 1, characterized in that: The multimodal task information is uniformly mapped to the task semantic graph space through a dedicated adapter. The dedicated adapter is used for text parsing, table parsing and image parsing. The text parsing includes extracting entities, operations and constraints from natural language instructions. The table parsing includes recognizing table structure, field semantics and relationships. The image parsing includes recognizing chart type, coordinate axes and key inflection points.

3. The method according to claim 2, characterized in that: The nodes of the task semantic graph include operation nodes, data object nodes, and condition nodes, and the edges represent logical dependencies, data flow, or causal relationships.

4. The method according to claim 3, characterized in that: The complexity metric includes a task complexity score calculated based on features such as node embedding modulus, importance distribution entropy, average connection density, and longest path length.

5. The method according to claim 4, characterized in that: The dynamic re-disassembly mechanism includes: The anomaly type, scope of impact, and original task description are jointly encoded into an enhanced Prompt. Use a large language model for structural re-evaluation; Insert or merge subtask nodes and update the task semantic graph.

6. The method according to claim 5, characterized in that: The construction of the error propagation causal graph based on historical execution trajectories includes: The PC algorithm is used to learn the causal structure from historical execution trajectories, and directional constraints and sparsity regularization are applied in conjunction with domain knowledge constraints. The PC algorithm includes the following steps: Construct the initial undirected graph; Perform conditional independence testing and pruning. Identify V-structures and determine edge directions; Estimate and sort the path propagation probabilities.

7. The method according to claim 6, characterized in that: The identification of high-frequency root cause paths and the preset fault-tolerance strategy include: The fault tolerance pre-set strategy is triggered in stages based on path confidence. When it is a high-risk path, defensive subtasks are automatically inserted and runtime assertions are set. When it is a medium-risk path, explicit reminders are added to the Prompt. When it is a low-risk path, it is only recorded to the monitoring log.

8. The method according to claim 7, characterized in that: The memory bank uses a vector database to store the task execution trajectory, which is used to continuously optimize the graph neural network model, complexity scoring function, and error propagation causal graph structure.

9. An iterative data analysis task execution system based on dynamic feedback and causal fault tolerance, characterized in that: It includes a multimodal data acquisition module, a task decomposition module, a dynamic re-decomposition module, a fault tolerance strategy construction module, and an optimization iteration module; The multimodal data acquisition module is used to receive multimodal task information input by the user, including natural language instructions, table images and trend graphs, and to construct a task semantic graph based on the multimodal task information; The task decomposition module is used to embed and quantify the task semantic graph based on graph neural networks and attention mechanisms to generate an initial task decomposition scheme. The dynamic re-disassembly module is used to monitor intermediate results during the execution of the initial task disassembly scheme. If an anomaly is detected, the dynamic re-disassembly mechanism is triggered to update the task semantic graph and task disassembly structure. The fault tolerance strategy construction module is used to construct an error propagation causal graph based on historical execution trajectories, identify high-frequency root cause paths, and pre-set fault tolerance strategies. The optimization iteration module is used to encode the entire process trajectory into a vector and store it in the memory bank after the task is completed, so as to optimize the subsequent task decomposition and the fault tolerance strategy.

10. A computer-readable storage medium, characterized in that: The computer-readable storage medium stores a computer program that, when executed by a processor, implements the steps of the method as described in any one of claims 1-8.

Images