Multi-stage task processing method and system based on intelligent Agent model

Abstract

The invention discloses a multi-stage task processing method and system based on an intelligent Agent model, and relates to the technical field of task processing, and the method comprises the steps: collecting heterogeneous data streams through a distributed sensor network, and generating a dynamic feature vector through a feature encoder inspired by quantum annealing; calculating a path expected utility value by using a Bayesian optimization algorithm, and projecting a high-order task space to a Kupman space; starting multi-thread asynchronous calculation, collecting execution state data in real time and constructing a causal graph model; the short-term execution logs are integrated through a neural Turing machine, edge computing nodes are called for distributed knowledge extraction, a multi-mode interpretable report is generated, and a long-term memory library is updated. According to the method, by starting multi-thread asynchronous calculation, the execution state data are collected in real time, the causal graph model is constructed, the execution result matrix with the confidence score is output, and the stability and reliability of task execution are improved.

Description

Technical Field

[0001] The present invention relates to the technical field of task processing, and particularly to a multi-stage task processing method and system based on an intelligent Agent model. Background Art

[0002] In recent years, with the rapid development of Internet of Things (IoT) technology, the application of distributed sensor networks has received extensive attention and research. Distributed sensor networks can efficiently collect and process heterogeneous data streams, including various types of real-time information such as temperature, humidity, pressure, images, radar signals, etc. Especially in the fields of industrial automation, smart cities, environmental monitoring, etc., the real-time processing and analysis of heterogeneous data streams are crucial. Currently, the combination of artificial intelligence-based algorithms (such as deep learning, reinforcement learning) and quantum computing provides a new approach to solving complex data analysis and task scheduling problems. Quantum annealing algorithms are particularly suitable for dealing with large-scale optimization problems, and they can find the global optimal solution in high-dimensional spaces, breaking through the limitations of traditional computing methods. However, most of the existing technologies focus on the static feature extraction of data streams and single-dimensional optimization tasks, and have not been able to effectively address the multi-task scheduling and efficient model combination problems in dynamic environments.

[0003] Currently, although there are many task scheduling methods based on intelligent algorithms, these methods generally face problems such as high computational complexity, low optimization accuracy, and imperfect modeling of task dependencies. In practical applications, traditional task scheduling methods mostly rely on classical optimization algorithms such as greedy algorithms and genetic algorithms. Although these methods perform well in certain specific situations, they often have the problem of local optimal solutions when facing a highly complex and dynamically changing task space. Especially in high-dimensional task spaces, the computational complexity of existing methods is relatively high, and they cannot effectively balance real-time performance and the global optimality of task scheduling. In addition, traditional methods are difficult to accurately model and schedule the complex dependencies between heterogeneous computing resources and tasks, lacking flexibility and scalability. The introduction of Bayesian optimization algorithms and quantum computing provides theoretical support for this problem. Bayesian optimization can efficiently find the optimal solution of the task path by establishing a probability model under limited computing resources, while quantum annealing simulators can break through the bottleneck of classical optimization algorithms to solve more complex task scheduling problems. Summary of the Invention

[0004] In view of the above existing problems, the present invention is proposed.

[0005] Therefore, the present invention provides a multi-stage task processing method based on an intelligent Agent model to solve the problems of low optimization accuracy and imperfect modeling of task dependencies in existing task scheduling methods.

[0006] To solve the above technical problems, the present invention provides the following technical solutions:

[0007] In a first aspect, the present invention provides a multi-stage task processing method based on an intelligent Agent model, which includes collecting heterogeneous data streams through a distributed sensor network, generating dynamic feature vectors using a quantum annealing-inspired feature encoder, updating a weight matrix, and outputting a standardized feature tensor; constructing a task state probability graph model based on the standardized feature tensor, calculating the path expected utility value using a Bayesian optimization algorithm, projecting the high-dimensional task space to the Koopman space, and generating a weighted task structure tree through a Monte Carlo tree search framework; constructing a Hamiltonian matrix according to the task structure tree, solving the heterogeneous model combination scheme through a quantum annealing simulator, and generating a model deployment instruction set; starting multi-threaded asynchronous computing, collecting execution status data in real time and constructing a causal graph model, outputting an execution result matrix with confidence scores, and obtaining short-term execution logs; integrating the short-term execution logs through a neural Turing machine, invoking edge computing nodes for distributed knowledge extraction, generating a multi-modal interpretable report, and updating the long-term memory library.

[0008] As a preferred solution of the multi-stage task processing method based on the intelligent Agent model of the present invention, wherein: the heterogeneous data streams include millimeter-wave radar signals, point cloud data, and visual data.

[0009] As a preferred solution of the multi-stage task processing method based on the intelligent Agent model of the present invention, wherein: the steps of collecting heterogeneous data streams through a distributed sensor network, generating dynamic feature vectors using a quantum annealing-inspired feature encoder, updating a weight matrix, and outputting a standardized feature tensor are specifically as follows:

[0010] Deploy a distributed sensor array, perform network protocol connection, and install heterogeneous computing units;

[0011] Synchronize the time and register the space of the sensor array, apply a sliding window mechanism to detect outliers, and perform data cleaning;

[0012] Extract underlying features from millimeter-wave radar signals, point cloud data, and visual data, and integrate them into a feature weight matrix;

[0013] Initialize the feature weight matrix to a fully connected state, break through the local optimum through the quantum tunneling effect, perform cross-dimensional weight recombination, and simulate the quantum annealing process;

[0014] Establish a dual-channel feedback loop through data-driven and task-driven to perform dynamic weight update;

[0015] Perform modal feature normalization on the feature weight matrix, perform cross-modal tensor fusion, and perform quality evaluation and compensation at the same time, and output a standardized feature tensor.

[0016] As a preferred solution of the multi-stage task processing method based on the intelligent Agent model of the present invention, wherein: constructing a task state probability graph model based on a standardized feature tensor, calculating the expected utility value of the path using the Bayesian optimization algorithm, projecting the high-dimensional task space to the Koopman space, and generating a weighted task structure tree through the Monte Carlo tree search framework. The specific steps are as follows:

[0017] Construct a task state probability graph model based on a Bayesian network through a standardized feature tensor. The nodes represent task states, and the edge weights are used to calculate the state transition probability through a sliding window.

[0018] Define a composite utility function, calculate the expected utility value of each path according to the task state probability graph model, and update it through Bayesian optimization to maximize the expected utility value.

[0019] Use the Koopman operator method to construct an observation function dictionary for the high-dimensional task space, and retain the leading principal components to achieve dimensionality reduction projection.

[0020] Real-time monitor the change rate of the projection residual, and update the feature dictionary according to the residual trigger.

[0021] Initialize the root node, branch factor, and node storage of the Monte Carlo tree structure, and perform four-stage iterative optimization to generate a task structure tree.

[0022] As a preferred solution of the multi-stage task processing method based on the intelligent Agent model of the present invention, wherein: constructing a Hamiltonian matrix according to the task structure tree, solving the heterogeneous model combination scheme through a quantum annealing simulator, and generating a model deployment instruction set. The specific steps are as follows:

[0023] Perform semantic parsing on the task structure tree, and map the node weights to Hamiltonian parameters.

[0024] Construct a Hamiltonian matrix. The main diagonal block adopts the eigenenergy term of the task node, and the off-diagonal block represents the coupling relationship between nodes. Real-time detect the load of the computing node, adjust the coupling coefficient of the corresponding matrix block, and eliminate the qubit crosstalk through a noise suppression factor.

[0025] Decompose the Hamiltonian matrix into a quadratic unconstrained binary optimization problem to generate a qubit mapping table.

[0026] Set a two-stage annealing strategy. In the coarse-tuning stage, quickly cool down to lock the global optimal region. In the fine-tuning stage, slowly cool down to eliminate local optimal traps, and obtain the heterogeneous model combination scheme through ground state interpretation.

[0027] Based on the heterogeneous model combination scheme, perform cross-platform instruction compilation and implement dynamic verification to generate a model deployment instruction set.

[0028] As a preferred solution of the multi-stage task processing method based on the intelligent Agent model of the present invention, wherein: for the start of multi-threaded asynchronous calculation, real-time collection of execution status data and construction of a causal graph model, and output of an execution result matrix with confidence scores, and obtaining short-term execution logs, the specific steps are as follows,

[0029] Deploy the translation model instruction set, create a thread pool, and perform multi-threaded asynchronous optimization calculation through pipeline parallelism and memory prefetching mechanisms;

[0030] Collect metrics at the hardware layer, software layer, and business layer, and perform segmented aggregation and outlier filtering;

[0031] Construct a three-layer causal graph association matrix for the hardware layer, task layer, and system layer, use Granger causality test to perform lag correlation relationships, and perform confidence scoring;

[0032] Sort out the short-term execution logs, compress them, and store them in the database.

[0033] As a preferred solution of the multi-stage task processing method based on the intelligent Agent model of the present invention, wherein: for integrating the short-term execution logs through a neural Turing machine, invoking edge computing nodes for distributed knowledge extraction, generating a multi-modal interpretable report, and updating the long-term memory library, the specific steps are as follows,

[0034] Extract short-term execution log fields through regular expressions, use the BERT-wwm model to generate semantic vectors for unstructured log texts, and construct an inverted index of keywords;

[0035] Construct a neural Turing machine memory matrix, slice and store log fields by minute in the time dimension, save semantic vectors in the semantic dimension, and establish an event causal chain in the association dimension;

[0036] Establish a dual-channel read-write head, where the coarse-grained read head locates relevant time slices, the fine-grained read head extracts specific event features, and use CAS atomic operations for conflict-free writing;

[0037] Divide the memory matrix into logical shards, allocate them to edge nodes, perform time series pattern mining, spatial association analysis, and causal strength calculation, and generate a multi-modal interpretable report;

[0038] Construct a three-level knowledge system for the long-term memory library, where the rule library solidifies high-frequency causal chains, the case library stores abnormal scenarios, the experience library records the history of parameter tuning, and update the long-term memory library based on the multi-modal interpretable report.

[0039] Second aspect, the present invention provides a multi-stage task processing system based on an intelligent Agent model, including a data acquisition module, a structure generation module, an instruction acquisition module, a log collation module, and a memory update module; the data acquisition module is used to collect heterogeneous data streams through a distributed sensor network, generate dynamic feature vectors using a quantum annealing-inspired feature encoder, update the weight matrix, and output a normalized feature tensor; the structure generation module is used to construct a task state probability graph model based on the normalized feature tensor, calculate the path expected utility value using a Bayesian optimization algorithm, project the high-level task space to the Koopman space, and generate a weighted task structure tree through a Monte Carlo tree search framework; the instruction acquisition module is used to construct a Hamiltonian matrix according to the task structure tree, solve the heterogeneous model combination scheme through a quantum annealing simulator, and generate a model deployment instruction set; the log collation module is used to start multi-threaded asynchronous calculation, collect execution status data in real time and construct a causal graph model, output an execution result matrix with a confidence score, and obtain short-term execution logs; the memory update module is used to integrate short-term execution logs through a neural Turing machine, call edge computing nodes for distributed knowledge extraction, generate a multi-modal interpretable report, and update the long-term memory library.

[0040] Third aspect, the present invention provides a computer device, including a memory and a processor, where the memory stores a computer program, and: when the computer program is executed by the processor, it implements any step of the multi-stage task processing method based on the intelligent Agent model as described in the first aspect of the present invention.

[0041] Fourth aspect, the present invention provides a computer-readable storage medium, on which a computer program is stored, and: when the computer program is executed by the processor, it implements any step of the multi-stage task processing method based on the intelligent Agent model as described in the first aspect of the present invention.

[0042] The beneficial effects of the present invention are as follows: By collecting heterogeneous data streams through a distributed sensor network, using a quantum annealing-inspired feature encoder to generate dynamic feature vectors and update the weight matrix, the efficient fusion of multi-source heterogeneous data and real-time feature extraction are ensured, providing high-quality data input for subsequent task modeling. Based on the standardized feature tensor, a task state probability graph model is constructed, combined with Bayesian optimization and Koopman space reduction, and a weighted task structure tree is generated through Monte Carlo tree search to accurately model the dependencies and state transitions between tasks, realizing the optimization of task scheduling and resource allocation. Using a quantum annealing simulator to solve the heterogeneous model combination scheme and generate a model deployment instruction set effectively solves the local optimality problem in high-dimensional task scheduling and ensures the reasonable allocation of resources. Starting multi-threaded asynchronous computing, collecting execution status data in real-time and constructing a causal graph model, and outputting an execution result matrix with confidence scores improves the stability and reliability of task execution. Integrating short-term execution logs through a neural Turing machine and performing distributed knowledge extraction with edge computing nodes to generate a multi-modal interpretable report and update the long-term memory library enhances the autonomous learning and continuous optimization capabilities of the scheme. BRIEF DESCRIPTION OF THE DRAWINGS

[0043] In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings required for the description of the embodiments will be briefly introduced below. Obviously, the drawings in the following description are only some embodiments of the present invention. For those of ordinary skill in the art, other drawings can be obtained based on these drawings without creative efforts.

[0044] Figure 1 It is a flowchart of the multi-stage task processing method based on the intelligent Agent model in Embodiment 1.

[0045] Figure 2 It is a module diagram of the multi-stage task processing system based on the intelligent Agent model in Embodiment 1. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0046] In order to make the above objects, features, and advantages of the present invention more obvious and understandable, the specific embodiments of the present invention will be described in detail below with reference to the drawings in the specification.

[0047] Many specific details are set forth in the following description in order to provide a thorough understanding of the present invention. However, the present invention may be practiced in other ways different from those described herein. Those skilled in the art can make similar extensions without departing from the spirit of the present invention. Therefore, the present invention is not limited by the specific embodiments disclosed below.

[0048] Second, the "one embodiment" or "embodiment" referred to herein means a specific feature, structure, or characteristic that may be included in at least one implementation manner of the present invention. The "in one embodiment" that appears in different places in this specification does not all refer to the same embodiment, nor is it an individual or selectively mutually exclusive embodiment with other embodiments.

[0049] Embodiment 1, referring to Figure 1 and Figure 2 , is the first embodiment of the present invention. This embodiment provides a multi-stage task processing method based on an intelligent Agent model, including the following steps:

[0050] S1: Collect heterogeneous data streams through a distributed sensor network, use a quantum annealing-inspired feature encoder to generate dynamic feature vectors, update the weight matrix, and output a normalized feature tensor.

[0051] Specifically, it includes the following steps:

[0052] S1.1: Deploy a distributed sensor array, establish a network protocol connection, and install heterogeneous computing units.

[0053] Specifically, the distributed sensor array includes a millimeter-wave radar (operating frequency band 76 - 81 GHz), a lidar (number of beams ≥ 128), and an industrial camera (resolution ≥ 4k). Each node establishes a low-power wide-area connection with the edge gateway through the LoRaWAN protocol.

[0054] The heterogeneous computing unit means that the radar node is equipped with a DSP chip to realize real-time processing of echo signals, the vision node integrates an NPU to accelerate YOLO object detection, and the lidar node uses an FPGA to realize point cloud preprocessing.

[0055] S1.1.1: The heterogeneous data streams include millimeter-wave radar signals, point cloud data, and visual data.

[0056] It should be understood that the millimeter-wave radar signals are collected by the millimeter-wave radar, the point cloud data is collected by the lidar, and the visual data is collected by the industrial camera.

[0057] S1.2: Perform time synchronization and spatial registration on the sensor array, apply a sliding window mechanism to detect outliers, and perform data cleaning.

[0058] Specifically, the time synchronization uses the IEEE 1588v2 precise clock protocol to achieve microsecond-level timestamp alignment; the spatial registration uses a three-dimensional coordinate system transformation based on a calibration board to construct a pose transformation matrix between sensors.

[0059] S1.3: Extract underlying features from the millimeter-wave radar signals, point cloud data, and visual data, and integrate them into a feature weight matrix.

[0060] It should be noted that the extracted underlying features include: extracting Doppler frequency shift and RCS scattering cross-section features from millimeter-wave radar signals; calculating normal vector histograms and curvature distributions from point cloud data; generating 128-dimensional visual descriptors from visual data through MobileNetV3.

[0061] S1.4: Initialize the feature weight matrix to a fully connected state, break through the local optimum through the quantum tunneling effect, perform cross-dimensional weight recombination, and simulate the quantum annealing process.

[0062] Specifically, each element of the feature weight matrix represents the correlation strength between feature dimensions.

[0063] When the Pearson correlation coefficient between features < 0.3, trigger the quantum tunneling effect, and randomly recombine 5%-15% of the weight connection paths;

[0064] The initial temperature of the annealing parameter is 1000, and the cooling rate is increased to 0.95 every 100 iterations.

[0065] S1.5: Establish a dual-channel feedback loop through data-driven and task-driven methods to perform dynamic weight updates.

[0066] Specifically, the data-driven channel calculates the feature variance based on a sliding window, and triggers weight updates when the variance exceeds the historical mean; the task-driven channel receives the upper-layer task feedback signal and adjusts the weight distribution through the gradient projection method.

[0067] S1.6: Perform modal feature normalization on the feature weight matrix, perform cross-modal tensor fusion, and at the same time perform quality assessment and compensation, and output the standardized feature tensor.

[0068] Specifically, for numerical data, use RobustScaler and set the IQR coefficient to 1.5; for image features, apply Layer-wise Adaptive Rate Scaling (LARS); for point cloud features, use spherical coordinate normalization.

[0069] Cross-modal tensor fusion refers to constructing a third-order tensor structure, where the N axis is the time series dimension (sampling interval is 100ms), the M axis is the feature dimension (fixed length 256), and the K axis is the modal dimension (millimeter-wave radar / vision / lidar).

[0070] Use the feature credibility index for quality assessment, and the expression is:

[0071]

[0072] Among them, W is the feature credibility index, e is the natural logarithm base, SNR is the signal-to-noise ratio of the feature weight matrix, and R 2 is the coefficient of determination;

[0073] Fuse the signal quality and interpretability in a multiplicative form to reflect the dual constraints of feature credibility. For example, high R 2 However, in the case of low SNR, overfitting may occur due to noise interference, and the credibility is limited; high SNR but low R 2 In the case of, it may be that the data quality is high but lacks predictive value (such as irrelevant environmental parameters collected).

[0074] When W < 0.6, call the data of adjacent nodes for interpolation repair.

[0075] Preferably, by deploying a distributed sensor array and applying dedicated hardware acceleration, heterogeneous data streams can be efficiently collected and preprocessed, realizing the time synchronization and spatial registration of different sensor data, and ensuring the consistency and accuracy of the data. Through a quantum annealing-inspired feature encoder, the feature weight matrix realizes cross-dimensional optimization, avoiding the local optimum problem and enhancing the correlation between features. Introducing a dual-channel feedback loop enables the feature weights to be dynamically updated according to data and task changes, enhancing adaptability and robustness. In addition, the modal feature normalization and cross-modal tensor fusion technology of features enable multi-modal data to work together in a unified feature space, optimizing data quality and processing efficiency.

[0076] S2: Construct a task state probability graph model based on the standardized feature tensor, use the Bayesian optimization algorithm to calculate the expected utility value of the path, project the high-dimensional task space to the Koopman space, and generate a weighted task structure tree through the Monte Carlo tree search framework.

[0077] Specifically, it includes the following steps:

[0078] S2.1: Construct a task state probability graph model based on the Bayesian network through the standardized feature tensor, where the nodes represent the task states, and the edge weights calculate the state transition probability through a sliding window.

[0079] Specifically, each task state node contains 5-dimensional attributes (task type, resource occupancy rate, execution time, priority label, anomaly mark) extracted from the standardized feature tensor, and is stored using a dynamic hash table, supporting O(1) complexity query.

[0080] The sliding window size for edge weight update is set to 10 task cycles, and the exponential decay weighting (decay factor is 0.85) is used for calculating the state transition frequency within the window.

[0081] S2.2: Define a composite utility function, calculate the expected utility value of each path according to the task state probability graph model, and update it through Bayesian optimization to maximize the expected utility value.

[0082] Specifically, the expression of the composite utility function is as follows:

[0083] U(π) = w1·S(π) + w2·(1 - Y(π)) + w3·D(π);

[0084] Where U(π) is the composite utility function, π is the path of the task state probability graph model, S(π) is the success rate of path execution (statistically based on historical logs), Y(π) is the resource consumption ratio (normalized value of CPU / memory occupancy), D(π) is the task criticality weight (mapped from a preset priority table), w1 is the coefficient of the path execution success rate (taking 0.6), w2 is the coefficient of the resource consumption ratio (taking 0.3), w3 is the coefficient of the task criticality weight (taking 0.1), and the values are determined by the Analytic Hierarchy Process (AHP).

[0085] The Gaussian Process (GP) is used to model the utility function, the kernel function is Matérn 5 / 2, and the Expected Improvement (EI) is used to select sampling points. In each round, the 5 paths with the largest EI are selected for actual utility evaluation, and the GP model is updated until convergence (the utility value fluctuation < 1% for 3 consecutive rounds).

[0086] S2.3: Using the Koopman operator method, construct an observation function dictionary for the high-dimensional task space, and retain the leading principal components to achieve dimensionality reduction projection.

[0087] Specifically, among the basis functions of the observation function dictionary, the first-order feature is the histogram of task state parameters (divided into 10 intervals), and the high-order feature is the Hermite polynomial expansion (up to the 3rd order).

[0088] The dictionary adopts the sparse coding method, and the objective function expression is:

[0089]

[0090] Where X is the expected utility value, O is the observation function dictionary, A is the coefficient matrix, and it is solved by the Alternating Direction Method of Multipliers (ADMM). is the Frobenius norm error, λ is the regularization coefficient, which is used to control the balance between the sparsity and fitting ability of sparse coding, obtained through cross-validation, ∥A∥1 is the L1 norm of A, and min is the identifier for taking the minimum value.

[0091] The number of dictionary atoms is adjusted dynamically (initially 200, and the maximum is expanded to 500).

[0092] Furthermore, the screening criterion for the principal components of dimensionality reduction projection is to retain the components with a cumulative contribution rate ≥ 95%, and force truncation when the variance ratio of adjacent components > 10%.

[0093] S2.4: Monitor the projection residual change rate in real time and update the feature dictionary according to the residual trigger.

[0094] Specifically, when the residual change rate in three consecutive cycles is greater than 5%, the feature dictionary update is triggered.

[0095] S2.5: Initialize the root node, branching factor, and node storage of the Monte Carlo tree structure, perform four-stage iterative optimization, and generate a task structure tree.

[0096] Specifically, the root node is set to the Koopman projection vector of the current task state; the initial number of branches of the branching factor is set to 5 and decays exponentially according to the node depth (the decay factor is 0.8).

[0097] The four-stage iterative optimization refers to:

[0098] Selection stage, starting from the root node, the strategy for selecting child nodes is:

[0099]

[0100] where v next is the next child node, argmax is the set of maximum independent variable points, v' is any child node in the current tree, v is the current node, Q(v') is the cumulative utility of node v', N(v') is the number of times node v' has been visited, N(v) is the number of times the current node v has been visited, and r is the exploration coefficient (taking 1.414);

[0101] Expansion stage, if the current node depth < 5 and it has not been fully explored, randomly add an unvisited child node v new ;

[0102] Simulation stage, starting from v new and randomly execute to the maximum depth based on the current strategy, and record the path utility U sim ;

[0103] Backpropagation stage, update all nodes on the path:

[0104] Q(v) ← Q(v) + U sim ;

[0105] N(v) ← N(v) + 1;

[0106] where Q(v) is the cumulative utility of the current node v, and U sim is the path utility calculated in the simulation stage;

[0107] Iteratively execute 200 times of MCTS, and finally select the branch with the highest Q(v) / N(v) under the root node as the backbone of the task structure tree, and the edge weight is the normalized Q(v).

[0108] Preferably, through the task status probability graph model, composite utility function, and Bayesian optimization, the path utility can be accurately evaluated and global optimization can be performed. The Koopman operator and dimensionality reduction algorithm reduce the computational complexity and maintain the key features of the task space. Real-time monitoring of the residual change and dynamic update of the feature dictionary ensure the adaptability and robustness of the method. MCTS generates an optimal task structure tree through iterative optimization, thereby providing an efficient task path selection. The overall solution improves the accuracy, efficiency, and adaptability of task scheduling. Especially when facing environmental changes, it can quickly respond and optimize decisions.

[0109] S3: Construct a Hamiltonian matrix according to the task structure tree, solve the heterogeneous model combination scheme through a quantum annealing simulator, and generate a model deployment instruction set.

[0110] Specifically, it includes the following steps:

[0111] S3.1: Perform semantic parsing on the task structure tree and map the node weights to Hamiltonian parameters.

[0112] Specifically, use breadth-first search (BFS) to traverse the task structure tree and generate a node parameter sequence in hierarchical order. Each node of the task structure tree contains two types of weights. The static weight is the task priority p i ∈[0,1], obtained by preset rules and historical data statistics. The dynamic weight is the execution cost c i , which is updated in real time.

[0113] By weighted summation of the static weight and the dynamic weight, obtain the eigenenergy term of the task node. Through the edge weight in the task structure tree, obtain the edge coupling strength. The expression is:

[0114] h i =-α·p i +β·c i ;

[0115]

[0116] where h i is the eigenenergy term of the task node, α is the static weight coefficient, used to control the influence of the task priority on the task eigenenergy term, and its value range is [0,1]. In this example, it takes 0.5, p i is the task priority, β is the dynamic weight coefficient, used to control the influence of the task execution cost on the task eigenenergy term, and its value range is [0.5,2]. In this example, it takes 1.5, c i is the execution cost, J ij is the edge coupling strength, γ is the global coupling coefficient, used to adjust the coupling strength between task nodes, that is, the influence degree of the interdependence between tasks on the system, and its value range is [0.1,1]. In this example, it takes 0.7, wij It represents the edge weight of the task structure tree, indicating the strength or relevance of the edges between task nodes in the task structure tree. The value range is [0, 10], and the value is determined according to the dependence strength between tasks. max(w) is the maximum value of the edge weight, i is a node in the task structure tree, and j is another node associated with i in the task structure tree.

[0117] S3.2: Construct the Hamiltonian matrix. The main diagonal block uses the eigen - energy term of the task node, the off - diagonal block represents the coupling relationship between nodes. Real - time detect the load of the computing node and adjust the coupling coefficient of the corresponding matrix block, and eliminate the qubit crosstalk through the noise suppression factor.

[0118] Specifically, the Hamiltonian matrix is a symmetric matrix that describes the energy and interaction between task nodes. The main diagonal elements of the matrix represent the eigen - energy terms of each task node, and the off - diagonal elements represent the edge coupling strength.

[0119] Real - time collect the resource occupancy rate of the computing node (the value range is [0, 1]). When the occupancy rate > 0.8, reduce the coupling coefficient of the computing node.

[0120] Introduce the noise factor The corrected coupling term is:

[0121] J ij ←J ij ·(1 - η·sgn(J ij ));

[0122] Among them, η is the noise factor, which is introduced as a random perturbation to introduce uncertainty and randomness, so as to avoid over - fitting. The value is randomly drawn from a normal distribution with a mean of 0 and a variance of 0.1, and sgn is the sign function.

[0123] S3.3: Decompose the Hamiltonian matrix into a quadratic unconstrained binary optimization problem and generate a qubit mapping table.

[0124] It should be understood that define the binary logical variable x i ∈{0, 1} to represent whether the task node v i is selected. The composition method of the quadratic unconstrained binary optimization (QUBO) matrix V is:

[0125] V nn =h i ;

[0126]

[0127] Among them, V nm is the value of the coordinate (n, n) in the QUBO matrix, V nm is the value of the coordinate (n, m) in the QUBO matrix, V mnis the value of the coordinate (m, n) in the QUBO matrix, where n is the abscissa of the QUBO matrix and m is the ordinate of the QUBO matrix;

[0128] According to the coupler distribution of the quantum annealing hardware (such as the D-Wave Pegasus architecture), map the binary logic variable x i to the physical qubit chain. If J ij ≠0, preferentially select the qubit pair where the physical coupler exists; for the coupling terms that cannot be directly mapped, construct a chain structure:

[0129] x i →q1, x j →q2;

[0130] J chain =-5.0 constrains q1 = q2;

[0131] where x i is the binary logic variable corresponding to the task node v i x j is the binary logic variable corresponding to the task node v j q1 is the qubit mapping the task node v i q2 is the qubit mapping the task node v j qubit, J chain is the strong coupling of the qubit.

[0132] S3.4: Set the two-stage annealing strategy. In the coarse-tuning stage, rapidly cool down to lock in the global optimal region. In the fine-tuning stage, slowly cool down to eliminate the local optimal traps, and obtain the heterogeneous model combination scheme through ground state decoding.

[0133] Specifically, the two-stage annealing strategy is divided into the coarse-tuning stage and the fine-tuning stage. The coarse-tuning stage is 0 - 50% of the time, with an initial temperature of 100 mK, cooling down at an exponential rate, aiming to quickly cross the energy barrier and lock in the global optimal region. The fine-tuning stage is 50 - 100% of the time, using linear cooling, aiming to finely search for the local optimal solution and eliminate the traps.

[0134] Read the final qubit state and generate the heterogeneous model combination scheme. For example, if x i = 1, deploy the computing model (such as CNN, LSTM, GNN, etc.) corresponding to the task node v i For the chained constraint variables, use majority voting to determine the final value.

[0135] S3.5: Based on the heterogeneous model combination scheme, perform cross-platform instruction compilation and implement dynamic verification to generate the model deployment instruction set.

[0136] Specifically, for the GPU platform, it is converted into a CUDA kernel function, and the computational graph is optimized using TensorRT. For the FPGA platform, Verilog hardware descriptions are generated, and the logic units are synthesized through Vivado. For the CPU cluster, it is encapsulated as an MPI task, and the number of processes is dynamically allocated.

[0137] Run the instruction set in a virtualized environment, collect the task completion time, resource utilization rate, and result accuracy. If the task completion time exceeds 20% of the prediction, or the result accuracy is less than 95%, then trigger the instruction set rollback and re-solve.

[0138] Preferably, by mapping the static and dynamic weights of the task nodes to Hamiltonian parameters, constructing a Hamiltonian matrix and dynamically adjusting the coupling coefficient, in real-time response to the computational node load and noise suppression, ensuring process stability and accuracy. Further optimize the task mapping through QUBO matrix transformation and chain structure processing, and combine the two-stage annealing strategy to balance global and local search, ensuring the global optimal solution. The cross-platform instruction compilation and dynamic verification mechanism ensure the efficient operation of the model on different hardware platforms. At the same time, optimize the task scheduling and resource allocation through the rollback mechanism, improving the utilization rate of computing resources and the accuracy of deployment.

[0139] S4: Start multi-threaded asynchronous computing, collect execution status data in real-time and construct a causal graph model, output an execution result matrix with confidence scores, and obtain short-term execution logs.

[0140] Specifically, it includes the following steps:

[0141] S4.1: Translate the model deployment instruction set, create a thread pool, and perform multi-threaded asynchronous optimization computing through pipeline parallelism and memory prefetching mechanisms.

[0142] Specifically, parse the model deployment instruction set in JSON format and convert it into a task object.

[0143] In the thread pool, the number of core threads is 0.8 times the number of CPU physical cores, reserving 20% as resource redundancy, the task queue capacity is 100, and the rejection policy is "discard the oldest task".

[0144] The pipeline parallelism stage is divided into data loading (IO-intensive, allocate 2 threads), model preprocessing (CPU computing, allocate 2 threads), and GPU inference (asynchronous CUDA stream, allocate 1 thread for monitoring).

[0145] The memory prefetch window size is 5, and the data of the next 5 tasks is pre-loaded into the shared cache according to the task dependency relationship.

[0146] S4.2: Collect metrics at the hardware layer, software layer, and business layer, and perform segmented aggregation and outlier filtering.

[0147] Specifically, the hardware layer metrics include CPU utilization, GPU video memory occupancy, and disk IOPS. The collection frequency is 100 ms, and the collection tools are Prometheus and NodeExporter. The software layer metrics include thread pool queue length, task latency, and cache hit rate. The collection frequency is 50 ms, and the collection tool is Agent tracing. The business layer metrics include task success rate, output accuracy, and data throughput. The collection frequency is triggered by task completion events, and the collection tool is log hooks.

[0148] Segmented aggregation means taking the mean, peak, and sum of the metrics within a 1-second time window.

[0149] Outlier filtering means using the Z-score method to mark data points that deviate from the mean and linearly interpolate and fill in the outliers.

[0150] S4.3: Construct a three-layer causal graph correlation matrix for the hardware layer, task layer, and system layer, perform lag correlation relationships using Granger causality tests, and conduct confidence scoring.

[0151] It should be noted that the causal direction hardware → task means that resource limitations lead to a decline in task performance. The causal direction task → system means that task backlogs trigger system-level bottlenecks. The causal direction system → hardware means that resource scheduling policies affect hardware utilization.

[0152] Furthermore, use the statsmodels library in Python to conduct Granger causality tests, determine the optimal lag order through the AIC criterion, and calculate the test statistic.

[0153] Confidence level C path = 1 - Pvalue, and the hierarchical aggregation expression is:

[0154] C = 0.4×C1 + 0.3×C2 + 0.3×C3;

[0155] Among them, C is the confidence score after hierarchical aggregation, C1 is the confidence score in the causal direction from the hardware layer to the task layer, C2 is the confidence score in the causal direction from the task layer to the system layer, C3 is the confidence score in the causal direction from the system layer to the hardware layer, and Pvalue is the p-value of the path.

[0156] S4.4: Organize the short-term execution logs, compress them, and store them in the database.

[0157] Specifically, use regular expressions to organize the execution logs, use columnar storage (Parquet format) + LZ4 compression, and store them in the MySQL database.

[0158] Preferably, the task execution is optimized by using a thread pool and a pipeline parallel mechanism, and the data transfer latency is reduced by memory prefetching to ensure efficient computing. Multidimensional metrics of the acquisition hardware, software, and business layer are collected, and accurate performance data is provided through segmented aggregation and outlier filtering. A three-layer causal graph correlation matrix is constructed and a Granger causality test is performed to analyze the lag correlation between layers, providing data support for optimization, and the reliability of the causal relationship is evaluated through a confidence score. The short-term execution logs are sorted, and the data access efficiency is improved through compression and columnar storage for subsequent analysis and tuning.

[0159] S5: Integrate the short-term execution logs through a neural Turing machine, call the edge computing nodes for distributed knowledge extraction, generate a multimodal interpretable report, and update the long-term memory library.

[0160] Specifically, it includes the following steps:

[0161] S5.1: Extract the short-term execution log fields through regular expressions, use the Bidirectional Encoder Representations from Transformers with Whole Word Masking (BERT-wwm) model based on the self-attention mechanism for processing sequence data encoders to generate semantic vectors for unstructured log texts, and construct an inverted index of keywords.

[0162] It should be understood that for structured texts, the corresponding fields are extracted using regular expressions, and for unstructured texts, the BERT-wwm-EXT-base model (hidden layer dimension 768) is used to extract semantic vectors, and the 768-dimensional vectors are compressed to 128 dimensions using PCA dimensionality reduction, retaining 95% of the variance.

[0163] Select the top 20 keywords based on Term Frequency-Inverse Document Frequency (TF-IDF) to construct a keyword mapping.

[0164] S5.2: Construct a neural Turing machine memory matrix. The time dimension stores the log fields sliced by minutes, the semantic dimension stores the semantic vectors, and the correlation dimension establishes an event causal chain.

[0165] Specifically, the time dimension is sliced by minutes, and each slice stores the log fields within 60 seconds; the semantic dimension is a 128-dimensional semantic vector space, and an IVF2048 index is constructed through the Faiss library to achieve fast nearest neighbor search. The causal chain in the correlation dimension is stored as a directed graph structure, and the edge weight is the causal strength.

[0166] Based on the three-layer causal graph correlation matrix generated by S4.3, strong correlation relationships (confidence score C > 0.8 after hierarchical aggregation) are extracted and written into the correlation dimension after alignment by time window.

[0167] S5.3: Establish a dual-channel read-write head. The coarse-grained read head locates the relevant time slices, the fine-grained read head extracts the specific event features, and the CAS atomic operation is used for conflict-free writing.

[0168] Specifically, the coarse-grained reader uses a B+ tree index, sorts by timestamp, and quickly retrieves time slices based on the query time range; the fine-grained reader filters events by semantic similarity (cosine distance < 0.2) within the target time slice and returns the top-10 related features.

[0169] The CAS mechanism uses a vector clock to mark event timing and resolve distributed write conflicts.

[0170] S5.4: Divide the memory matrix into logical slices and assign them to edge nodes to perform temporal pattern mining, spatial correlation analysis, and causal strength calculation to generate multimodal interpretable reports.

[0171] Specifically, based on the time range (every 30 minutes) and semantic clustering (K-means, k=50), logical sharding is performed with a shard size of ≤1GB, and the ConsistentHashing algorithm is used for edge node allocation, with a node load difference of <5%.

[0172] The Matrix Profile (window size = 60) algorithm was used to mine time series patterns and detect periodic anomalies; spatial association analysis was performed by calculating the Pearson correlation coefficient; and transfer entropy was calculated to quantify causal influence.

[0173] Multimodal interpretable reports contain temporal features, spatial associations, and causal chains.

[0174] S5.5: Construct a three-level knowledge system for the long-term memory library. The rule library solidifies high-frequency causal chains, the case library stores abnormal scenarios, and the experience library records parameter tuning history. The long-term memory library is updated based on multimodal interpretable reports.

[0175] Specifically, the rule base stores IF-THEN type high-frequency causal chains (confidence > 0.9) and merges similar rules every 24 hours (Jaccard similarity > 0.8); the case base stores snapshots of abnormal scenarios (indicators + logs + causal graphs), retains the Top-100 latest cases, and eliminates LRU; the experience base stores parameter tuning history (hyperparameters + effect indicators).

[0176] Extract the causal chain from the multimodal interpretable report, and write it into the rule base if it appears three times in a row and the confidence level increases. For abnormal scenarios, save the system snapshots (including indicators, logs, and causal diagrams) 5 minutes before and after.

[0177] Preferably, use the BERT-wwm model to extract the semantic vectors of unstructured logs, construct a memory matrix and organize it by time, semantics, and causal chains. Implement efficient event retrieval through a dual-channel read-write head to avoid distributed write conflicts. Divide the memory matrix into logical shards and allocate them to edge nodes for time-series pattern mining and causal analysis, generate an interpretable report, update the long-term memory library based on the report, solidify high-frequency causal chains, and store abnormal scenarios and tuning history, thereby improving the intelligence and automation level of the solution and continuously optimizing the decision-making ability.

[0178] This embodiment also provides a multi-stage task processing system based on an intelligent Agent model, including: a data acquisition module for collecting heterogeneous data streams through a distributed sensor network, generating dynamic feature vectors using a quantum annealing-inspired feature encoder, updating the weight matrix, and outputting a normalized feature tensor; a structure generation module for constructing a task state probability graph model based on the normalized feature tensor, calculating the path expected utility value using a Bayesian optimization algorithm, projecting the high-dimensional task space to the Koopman space, and generating a weighted task structure tree through a Monte Carlo tree search framework; an instruction acquisition module for constructing a Hamiltonian matrix according to the task structure tree, solving the heterogeneous model combination scheme through a quantum annealing simulator, and generating a model deployment instruction set; a log sorting module for starting multi-threaded asynchronous computing, collecting execution status data in real time and constructing a causal graph model, outputting an execution result matrix with confidence scores, and obtaining short-term execution logs; a memory update module for integrating short-term execution logs through a neural Turing machine, invoking edge computing nodes for distributed knowledge extraction, generating a multi-modal interpretable report, and updating the long-term memory library.

[0179] This embodiment also provides a computer device applicable to the case of the multi-stage task processing method based on the intelligent Agent model, including: a memory and a processor; the memory is used to store computer-executable instructions, and the processor is used to execute the computer-executable instructions to implement the multi-stage task processing method based on the intelligent Agent model proposed in the above embodiment.

[0180] The computer device may be a terminal, which includes a processor, a memory, a communication interface, a display screen, and an input device connected via a system bus. Among them, the processor of the computer device is used to provide computing and control capabilities. The memory of the computer device includes a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system and computer programs. The internal memory provides an environment for the operation of the operating system and computer programs in the non-volatile storage medium. The communication interface of the computer device is used to communicate with external terminals in a wired or wireless manner, and the wireless manner can be achieved through WIFI, a carrier network, NFC (Near Field Communication), or other technologies. The display screen of the computer device can be a liquid crystal display screen or an electronic ink display screen. The input device of the computer device can be a touch layer covering the display screen, or a button, a trackball, or a touchpad provided on the housing of the computer device, or an external keyboard, touchpad, or mouse, etc.

[0181] This embodiment also provides a storage medium, on which a computer program is stored. When the program is executed by a processor, it implements the multi-stage task processing method based on the intelligent Agent model as proposed in the above embodiment; the storage medium can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as Static Random Access Memory (SRAM), Electrically Erasable Programmable Read-Only Memory (EEPROM), Erasable Programmable Read Only Memory (EPROM), Programmable Red-Only Memory (PROM), Read-Only Memory (ROM), magnetic memory, flash memory, a magnetic disk, or an optical disc.

[0182] In summary, the present invention: collects heterogeneous data streams through a distributed sensor network, uses a quantum annealing-inspired feature encoder to generate dynamic feature vectors and update the weight matrix, ensuring the efficient fusion of multi-source heterogeneous data and real-time feature extraction, and providing high-quality data input for subsequent task modeling. Based on the standardized feature tensor, a task state probability graph model is constructed, combined with Bayesian optimization and Koopman space reduction, and a weighted task structure tree is generated through Monte Carlo tree search to accurately model the dependencies and state transitions between tasks, realizing the optimization of task scheduling and resource allocation. A quantum annealing simulator is used to solve the heterogeneous model combination scheme and generate a model deployment instruction set, effectively solving the local optimum problem in high-dimensional task scheduling and ensuring the reasonable allocation of resources. Multithreaded asynchronous computing is started to collect execution status data in real time and construct a causal graph model, outputting an execution result matrix with confidence scores, improving the stability and reliability of task execution. The short-term execution logs are integrated through a neural Turing machine, and distributed knowledge extraction is carried out with the help of edge computing nodes to generate a multi-modal interpretable report and update the long-term memory bank, enhancing the autonomous learning and continuous optimization capabilities of the scheme.

[0183] It should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and not to limit them. Although the present invention has been described in detail with reference to the preferred embodiments, those of ordinary skill in the art should understand that the technical solutions of the present invention can be modified or equivalently replaced without departing from the spirit and scope of the technical solutions of the present invention, and they should all be covered by the scope of the claims of the present invention.

Claims

1. A multi-stage task processing method based on an intelligent Agent model, characterized in that: including collecting heterogeneous data streams through a distributed sensor network, generating dynamic feature vectors using a quantum annealing-inspired feature encoder, updating the weight matrix, and outputting a normalized feature tensor constructing a task state probability graph model based on the normalized feature tensor, calculating the path expected utility value using the Bayesian optimization algorithm, projecting the high-dimensional task space into the Koopman space, and generating a weighted task structure tree through the Monte Carlo tree search framework constructing a Hamiltonian matrix according to the task structure tree, solving the heterogeneous model combination scheme through a quantum annealing simulator, and generating a model deployment instruction set starting multi-threaded asynchronous computing, collecting execution status data in real time and constructing a causal graph model, outputting an execution result matrix with confidence scores, and obtaining short-term execution logs integrating short-term execution logs through a neural Turing machine, calling edge computing nodes for distributed knowledge extraction, generating a multi-modal interpretable report, and updating the long-term memory library 2. The multi-stage task processing method based on the intelligent Agent model according to claim 1, characterized in that: The heterogeneous data streams include millimeter-wave radar signals, point cloud data, and visual data 3. The multi-stage task processing method based on the intelligent Agent model according to claim 2, wherein: The steps of collecting heterogeneous data streams through a distributed sensor network, generating dynamic feature vectors using a quantum annealing-inspired feature encoder, updating the weight matrix, and outputting a normalized feature tensor are as follows Deploying a distributed sensor array, making network protocol connections, and installing heterogeneous computing units Performing time synchronization and spatial registration on the sensor array, applying a sliding window mechanism to detect outliers, and performing data cleaning Extracting underlying features from millimeter-wave radar signals, point cloud data, and visual data, and integrating them into a feature weight matrix Initializing the feature weight matrix to a fully connected state, breaking through the local optimum through the quantum tunneling effect, performing cross-dimensional weight recombination, and simulating the quantum annealing process Establishing a two-channel feedback loop through data-driven and task-driven methods to perform dynamic weight updates Performing modal feature normalization on the feature weight matrix, performing cross-modal tensor fusion, and performing quality assessment and compensation at the same time, and outputting a normalized feature tensor 4. The multi-stage task processing method based on the intelligent Agent model according to claim 3, wherein: The steps of constructing a task state probability graph model based on the normalized feature tensor, calculating the path expected utility value using the Bayesian optimization algorithm, projecting the high-dimensional task space into the Koopman space, and generating a weighted task structure tree through the Monte Carlo tree search framework are as follows Constructing a task state probability graph model based on a Bayesian network through the normalized feature tensor, where the nodes represent task states and the edge weights calculate the state transition probability through a sliding window Defining a composite utility function, calculating the expected utility value of each path according to the task state probability graph model, and updating it through Bayesian optimization to maximize the expected utility value Using the Koopman operator method, constructing an observation function dictionary for the high-dimensional task space, and retaining the leading principal components to achieve dimensionality reduction projection Real-time monitoring of the projection residual change rate, and triggering feature dictionary updates according to the residuals Initializing the root node, branching factor, and node storage of the Monte Carlo tree structure, and performing four-stage iterative optimization to generate a task structure tree 5. The multi-stage task processing method based on the intelligent Agent model according to claim 4, characterized in that: The steps of constructing a Hamiltonian matrix according to the task structure tree, solving the heterogeneous model combination scheme through a quantum annealing simulator, and generating a model deployment instruction set are as follows Semantically parse the task structure tree and map the node weights to Hamiltonian parameters; Construct a Hamiltonian matrix. The main diagonal blocks use the eigen-energy terms of task nodes, and the off-diagonal blocks represent the coupling relationships between nodes. Real-time detect the load of computing nodes, adjust the coupling coefficients of the corresponding matrix blocks, and eliminate qubit crosstalk through a noise suppression factor; Decompose the Hamiltonian matrix into a quadratic unconstrained binary optimization problem to generate a qubit mapping table; Set a two-stage annealing strategy. In the coarse-tuning stage, rapidly cool down to lock in the global optimal region. In the fine-tuning stage, slowly cool down to eliminate local optimal traps, and obtain a heterogeneous model combination scheme through ground state interpretation; Based on the heterogeneous model combination scheme, perform cross-platform instruction compilation and implement dynamic verification to generate a model deployment instruction set.

6. The multi-stage task processing method based on the intelligent Agent model according to claim 5, characterized in that: The start of multi-threaded asynchronous computing, real-time collection of execution status data and construction of a causal graph model, output of an execution result matrix with confidence scores, and obtain short-term execution logs. The specific steps are as follows: Translate the model deployment instruction set, create a thread pool, and perform multi-threaded asynchronous optimization computing through pipeline parallelism and memory prefetching mechanisms; Collect metrics at the hardware layer, software layer, and business layer, and perform segmented aggregation and outlier filtering; Construct a three-layer causal graph correlation matrix for the hardware layer, task layer, and system layer, use Granger causality tests to perform lag correlation relationships, and perform confidence scoring; Organize the short-term execution logs, compress them, and store them in the database.

7. The multi-stage task processing method based on the intelligent Agent model according to claim 6, wherein: The integration of short-term execution logs through a neural Turing machine, call edge computing nodes for distributed knowledge extraction, generate a multi-modal interpretable report, and update the long-term memory bank. The specific steps are as follows: Extract short-term execution log fields through regular expressions, use the BERT-wwm model to generate semantic vectors for unstructured log texts, and construct an inverted index of keywords; Construct a neural Turing machine memory matrix. In the time dimension, slice and store log fields by minute. In the semantic dimension, save semantic vectors. In the association dimension, establish an event causal chain; Establish a dual-channel read-write head. The coarse-grained read head locates relevant time slices, and the fine-grained read head extracts specific event features. Use CAS atomic operations for conflict-free writing; Divide the memory matrix into logical shards, allocate them to edge nodes, perform temporal pattern mining, spatial association analysis, and causal strength calculation, and generate a multi-modal interpretable report; Construct a three-level knowledge system for the long-term memory bank. The rule base solidifies high-frequency causal chains, the case base stores abnormal scenarios, and the experience base records the history of parameter tuning. Update the long-term memory bank based on the multi-modal interpretable report.

8. A multi-stage task processing system based on an intelligent Agent model, based on the multi-stage task processing method based on the intelligent Agent model according to any one of claims 1 to 7, characterized in that: Including a data collection module, a structure generation module, an instruction acquisition module, a log organization module, and a memory update module; The data collection module is used to collect heterogeneous data streams through a distributed sensor network, use a feature encoder inspired by quantum annealing to generate dynamic feature vectors, update the weight matrix, and output a standardized feature tensor; The structure generation module is used to construct a task state probability graph model based on the standardized feature tensor, use the Bayesian optimization algorithm to calculate the path expected utility value, project the high-dimensional task space to the Koopman space, and generate a weighted task structure tree through the Monte Carlo tree search framework; The instruction acquisition module is configured to construct a Hamiltonian matrix according to the task structure tree, solve the heterogeneous model combination scheme through a quantum annealing simulator, and generate a model deployment instruction set; The log collation module is configured to start multi-threaded asynchronous computing, collect execution status data in real time and construct a causal graph model, output an execution result matrix with confidence scores, and obtain short-term execution logs; The memory update module is configured to integrate short-term execution logs through a neural Turing machine, call edge computing nodes for distributed knowledge extraction, generate a multi-modal interpretable report, and update the long-term memory library.

9. A computer device, comprising a memory and a processor, the memory storing a computer program, characterized in that: When the processor executes the computer program, the steps of the multi-stage task processing method based on the intelligent Agent model according to any one of claims 1 to 7 are implemented.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by the processor, the steps of the multi-stage task processing method based on the intelligent Agent model according to any one of claims 1 to 7 are implemented.

Images