A multi-stage task processing method and system based on intelligent agent model

Abstract

The present invention discloses a multi-stage task processing method and system based on an intelligent agent model, relating to the field of task processing technology. The method comprises collecting heterogeneous data streams through a distributed sensor network and generating dynamic feature vectors using a quantum annealing-inspired feature encoder; calculating the expected utility value of paths using a Bayesian optimization algorithm and projecting the high-level task space into a Koopman space; initiating multi-threaded asynchronous computing, collecting execution status data in real time, and constructing a causal graph model; integrating short-term execution logs through a neural Turing machine, calling edge computing nodes for distributed knowledge extraction, generating multimodal interpretable reports, and updating long-term memory. By initiating multi-threaded asynchronous computing, collecting execution status data in real time, constructing a causal graph model, and outputting an execution result matrix with confidence scores, the present invention improves the stability and reliability of task execution.

Description

Technical Field

[0001] The present invention relates to the technical field of task processing, and in particular 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 garnered widespread attention and research. Distributed sensor networks can efficiently collect and process heterogeneous data streams, including real-time information such as temperature, humidity, pressure, images, radar signals, and other types of information. Real-time processing and analysis of heterogeneous data streams are crucial, particularly in areas such as industrial automation, smart cities, and environmental monitoring. Currently, the combination of artificial intelligence-based algorithms (such as deep learning and reinforcement learning) and quantum computing offers a new approach to solving complex data analysis and task scheduling problems. Quantum annealing algorithms are particularly well-suited for large-scale optimization problems, capable of finding global optimal solutions in high-dimensional spaces, breaking through the limitations of traditional computational methods. However, most existing technologies focus on static feature extraction of data streams and single-dimensional optimization tasks, and have yet to effectively address multi-task scheduling and efficient model combination in dynamic environments.

[0003] Although numerous task scheduling methods based on intelligent algorithms have been developed, they generally face challenges such as high computational complexity, low optimization accuracy, and incomplete modeling of task dependencies. In practical applications, traditional task scheduling methods often rely on classical optimization algorithms, such as greedy algorithms and genetic algorithms. While these methods perform well in certain situations, they often struggle with local optimal solutions when faced with highly complex and dynamically changing task spaces. Existing methods suffer from high computational complexity, particularly in high-dimensional task spaces, making them unable to effectively balance real-time requirements with global optimality in task scheduling. Furthermore, traditional methods struggle 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 addressing these issues. Bayesian optimization can efficiently find optimal solutions for task paths by establishing probabilistic models even with limited computing resources, while quantum annealing simulators can overcome the bottlenecks of classical optimization algorithms, enabling the solution of even 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 task dependency modeling in existing task scheduling methods.

[0006] In order to solve the above technical problems, the present invention provides the following technical solutions:

[0007] In the 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, using a quantum annealing-inspired feature encoder to generate dynamic feature vectors, updating a weight matrix, and outputting a standardized feature tensor; constructing a task state probability graph model based on the standardized feature tensor, using a Bayesian optimization algorithm to calculate the expected utility value of the path, projecting the high-order task space into 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 a short-term execution log; integrating the short-term execution log through a neural Turing machine, calling edge computing nodes for distributed knowledge extraction, generating a multimodal 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 described in the present invention, the heterogeneous data stream includes 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 described in the present invention, wherein: the distributed sensor network is used to collect heterogeneous data streams, a quantum annealing-inspired feature encoder is used to generate dynamic feature vectors, the weight matrix is ​​updated, and the standardized feature tensor is output. The specific steps are:

[0010] Deploy distributed sensor arrays, connect them through network protocols, and install heterogeneous computing units;

[0011] Temporally synchronize and spatially register the sensor array, apply a sliding window mechanism to detect outliers, and perform data cleaning;

[0012] Extract low-level 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 reorganization, and simulate the quantum annealing process;

[0014] Establish a dual-channel feedback loop through data-driven and task-driven methods to dynamically update weights;

[0015] Modal feature normalization is performed on the feature weight matrix, and cross-modal tensor fusion is performed. Quality assessment and compensation are also performed simultaneously to output a standardized feature tensor.

[0016] As a preferred solution of the multi-stage task processing method based on the intelligent agent model described in the present invention, the task state probability graph model is constructed based on the standardized feature tensor, the path expected utility value is calculated using the Bayesian optimization algorithm, the high-level task space is projected into the Koopman space, and a weighted task structure tree is generated through the Monte Carlo tree search framework. The specific steps are as follows:

[0017] A Bayesian network-based task state probability graph model is constructed by normalizing the feature tensor. The nodes represent the task states, and the edge weights calculate the state transition probability through a sliding window.

[0018] Define a composite utility function, calculate the expected utility value of each path based on 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 the observation function dictionary of the high-dimensional task space and retain the front principal components to achieve dimensionality reduction projection;

[0020] Monitor the rate of change of projection residuals in real time and trigger feature dictionary updates based on the residuals;

[0021] 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.

[0022] As a preferred solution of the multi-stage task processing method based on the intelligent agent model described in the present invention, the Hamiltonian matrix is ​​constructed according to the task structure tree, the heterogeneous model combination scheme is solved by the quantum annealing simulator, and the model deployment instruction set is generated. The specific steps are as follows:

[0023] Perform semantic analysis on the task structure tree and map node weights to Hamiltonian parameters;

[0024] Construct the Hamiltonian matrix. The main diagonal block uses the task node intrinsic energy term, and the off-diagonal block is the coupling relationship between nodes. The computing node load is detected in real time, the coupling coefficient of the corresponding matrix block is adjusted, and the quantum bit crosstalk is eliminated through the noise suppression factor.

[0025] Decompose the Hamiltonian matrix into a quadratic unconstrained binary optimization problem and generate a quantum bit mapping table;

[0026] A two-stage annealing strategy is set up, with rapid cooling in the coarse adjustment stage to lock the global optimal region, and slow cooling in the fine adjustment stage to eliminate local optimal traps, and a heterogeneous model combination solution is obtained through ground state interpretation;

[0027] Based on the heterogeneous model combination solution, cross-platform instruction compilation is performed, dynamic verification is implemented, and a model deployment instruction set is generated.

[0028] As a preferred solution of the multi-stage task processing method based on the intelligent agent model described in the present invention, wherein: the multi-threaded asynchronous computing is started, the execution status data is collected in real time and a causal graph model is constructed, the execution result matrix with confidence score is output, and the short-term execution log is obtained. The specific steps are:

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

[0030] Collect hardware, software, and business layer metrics, perform segmented aggregation, and filter outliers;

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

[0032] Organize 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 described in the present invention, the method integrates short-term execution logs through the neural Turing machine, calls edge computing nodes for distributed knowledge extraction, generates multimodal interpretable reports and updates long-term memory libraries. The specific steps are as follows:

[0034] We use regular expressions to extract short-term execution log fields, use the BERT-wwm model to generate semantic vectors for unstructured log text, and build a keyword inverted index.

[0035] Construct a neural Turing machine memory matrix, with the time dimension slicing and storing log fields by minute, the semantic dimension storing semantic vectors, and the association dimension establishing an event causal chain;

[0036] Establish a dual-channel read / write head. The coarse-grained read head locates the relevant time slices, and the fine-grained read head extracts specific event features. CAS atomic operations are used for anti-collision writing.

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

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

[0039] In a second aspect, the present invention provides a multi-stage task processing system based on an intelligent agent model, comprising 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 a 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, calculate the path expected utility value using a Bayesian optimization algorithm, project the high-level task space into the Koopman space, and generate a weighted task structure tree using a Monte Carlo tree search framework; the instruction acquisition module is used to construct a Hamiltonian matrix based on the task structure tree, solve the heterogeneous model combination scheme using a quantum annealing simulator, and generate a model deployment instruction set; the log collation module is used to start multi-threaded asynchronous computing, collect execution status data in real time and build a causal graph model, output an execution result matrix with confidence scores, and obtain short-term execution logs; the memory update module is used to integrate short-term execution logs using a neural Turing machine, call edge computing nodes for distributed knowledge extraction, generate multimodal interpretable reports, and update the long-term memory library.

[0040] In a third aspect, the present invention provides a computer device comprising a memory and a processor, wherein the memory stores a computer program, wherein: when the computer program is executed by the processor, 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 is implemented.

[0041] In a fourth aspect, the present invention provides a computer-readable storage medium having a computer program stored thereon, wherein: when the computer program is executed by a 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: heterogeneous data streams are collected through a distributed sensor network, and a quantum annealing-inspired feature encoder is used to generate dynamic feature vectors and update the weight matrix, ensuring efficient fusion and real-time feature extraction of multi-source heterogeneous data, providing high-quality data input for subsequent task modeling. A task state probabilistic graph model is constructed based on a standardized feature tensor, and combined with Bayesian optimization and Koopman space dimensionality reduction, a weighted task structure tree is generated through Monte Carlo tree search, accurately modeling the dependencies and state transitions between tasks, and achieving 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 optimality problem in high-dimensional task scheduling and ensuring the rational allocation of resources. Multi-threaded asynchronous computing is enabled, execution status data is collected in real time, and a causal graph model is constructed. The execution result matrix with confidence scores is output, improving the stability and reliability of task execution. Short-term execution logs are integrated through a neural Turing machine, and distributed knowledge extraction is performed with the help of edge computing nodes. Multimodal interpretable reports are generated and the long-term memory library is updated, enhancing the program's autonomous learning and continuous optimization capabilities. BRIEF DESCRIPTION OF THE DRAWINGS

[0043] In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the following briefly introduces the drawings required for use in the description of the embodiments. Obviously, the drawings described below are only some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative work.

[0044] Figure 1 Flowchart of the multi-stage task processing method based on the intelligent agent model in Example 1.

[0045] Figure 2 This is a module diagram of the multi-stage task processing system based on the intelligent agent model in Example 1. DETAILED DESCRIPTION

[0046] In order to make the above-mentioned objects, features and advantages of the present invention more obvious and easy to understand, the specific embodiments of the present invention are described in detail below with reference to the accompanying drawings.

[0047] In the following description, many specific details are set forth to facilitate a full understanding of the present invention. However, the present invention may also be implemented in other ways different from those described herein. Those skilled in the art may make similar generalizations without violating the connotation of the present invention. Therefore, the present invention is not limited to the specific embodiments disclosed below.

[0048] Secondly, the term "one embodiment" or "embodiment" herein refers to a specific feature, structure, or characteristic that may be included in at least one implementation of the present invention. The phrase "in one embodiment" appearing in various places throughout this specification does not necessarily refer to the same embodiment, nor does it refer to a separate or selective embodiment that is mutually exclusive of other embodiments.

[0049] Example 1, with reference to Figure 1 and Figure 2 , which is the first embodiment of the present invention, provides a multi-stage task processing method based on an intelligent agent model, comprising the following steps:

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

[0051] Specifically, the following steps are included:

[0052] S1.1: Deploy distributed sensor arrays, connect them through network protocols, and install heterogeneous computing units.

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

[0054] Heterogeneous computing units refer to radar nodes equipped with DSP chips to achieve real-time processing of echo signals, visual nodes integrated with NPU to accelerate YOLO target detection, and lidar nodes using FPGA to achieve point cloud preprocessing.

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

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

[0057] S1.2: Temporally synchronize and spatially register the sensor array, apply a sliding window mechanism to detect outliers, and perform data cleaning.

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

[0059] S1.3: Extract low-level features from 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 histogram and curvature distribution from point cloud data; and generating a 128-dimensional visual descriptor 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 reorganization, and simulate the quantum annealing process.

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

[0063] When the Pearson correlation coefficient between features is less than 0.3, the quantum tunneling effect is triggered, and 5%-15% of the weighted connection paths are randomly reorganized;

[0064] The initial temperature of the annealing parameters 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 dynamically update weights.

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

[0067] S1.6: Perform modal feature normalization on the feature weight matrix and perform cross-modal tensor fusion, while performing quality assessment and compensation, and outputting a standardized feature tensor.

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

[0069] Cross-modal tensor fusion refers to the construction of a three-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] The quality assessment is performed using the feature credibility index, which is expressed as:

[0071]

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

[0073] By integrating signal quality and explanatory power in a product form, the dual constraints of feature credibility are reflected. 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 some cases, the data may be of high quality but lack predictive value (e.g., irrelevant environmental parameters were collected).

[0074] When W<0.6, the adjacent node data is called 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, achieving time synchronization and spatial alignment of data from different sensors, ensuring data consistency and accuracy. Through a quantum annealing-inspired feature encoder, the feature weight matrix is ​​optimized across dimensions, avoiding local optimality problems and improving the correlation between features. The introduction of a dual-channel feedback loop allows 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 multimodal 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-level task space into the Koopman space, and generate a weighted task structure tree through the Monte Carlo tree search framework.

[0077] Specifically, the following steps are included:

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

[0079] Specifically, each task status node contains five-dimensional attributes (task type, resource occupancy, execution time, priority label, and exception label) extracted from the standardized feature tensor, which is stored in a dynamic hash table and supports O(1) complexity queries.

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

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

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

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

[0084] Among them, U(π) is the composite utility function, π is the path of the task state probability graph model, S(π) is the path execution success rate (based on historical log statistics), Y(π) is the resource consumption ratio (CPU / memory occupancy normalized value), D(π) is the task criticality weight (preset priority table mapping), w1 is the path execution success rate coefficient (taken as 0.6), w2 is the resource consumption ratio coefficient (taken as 0.3), and w3 is the task criticality weight coefficient (taken as 0.1). The value is determined by the analytic hierarchy process (AHP).

[0085] The utility function was modeled using a Gaussian process (GP) with a Matérn 5 / 2 kernel function. Expected Improvement (EI) was used to select sampling points. In each round, the five paths with the largest EI were selected for actual utility evaluation, and the GP model was updated until convergence (utility fluctuations < 1% for three rounds).

[0086] S2.3: Use the Koopman operator method to construct the observation function dictionary of the high-dimensional task space and retain the front principal components to achieve dimensionality reduction projection.

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

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

[0089]

[0090] Among them, X is the expected utility value, O is the observation function dictionary, and A is the coefficient matrix, which is solved by the alternating direction multiplication method. 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 and is obtained through cross-validation. ∥A∥1 is the L1 norm of A, and min is the minimum value identifier.

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

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

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

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

[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 it decays exponentially according to the node depth (the decay factor is 0.8).

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

[0098] In the selection phase, starting from the root node, the strategy for selecting child nodes is:

[0099]

[0100] Among them, v next is the next child node, argmax is the maximum independent variable point set, 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 (taken as 1.414);

[0101] In the expansion phase, if the current node depth is less than 5 and has not been fully explored, a random unvisited child node v is added. new ;

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

[0103] In the backtracking phase, all nodes on the path are updated:

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

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

[0106] Among them, Q(v) is the cumulative utility of the current node v, U sim the path utilities calculated for the simulation phase;

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

[0108] Optimally, the task-state probabilistic graph model, composite utility function, and Bayesian optimization enable precise evaluation of path utility and global optimization. The Koopman operator and dimensionality reduction algorithm reduce computational complexity while preserving key features of the task space. Real-time monitoring of residual changes and dynamic updating of the feature dictionary ensure the adaptability and robustness of the method. MCTS generates an optimal task structure tree through iterative optimization, providing efficient task path selection. The overall solution improves the accuracy, efficiency, and adaptability of task scheduling, enabling rapid response and optimized decision-making in the face of environmental changes.

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

[0110] Specifically, the following steps are included:

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

[0112] Specifically, breadth-first search (BFS) is used to traverse the task structure tree and generate node parameter sequences in hierarchical order. Each node in 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 , updated in real time.

[0113] The task node intrinsic energy term is obtained by weighted summation of static weight and dynamic weight. The edge coupling strength is obtained by edge weight in the task structure tree. The expression is:

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

[0115]

[0116] Among them, h i is the intrinsic energy item of the task node, α is the static weight coefficient, which is used to control the impact of task priority on the intrinsic energy item of the task. Its value range is [0,1]. In this example, it is 0.5. i is the task priority, β is the dynamic weight coefficient, which is used to control the impact of the task execution cost on the task intrinsic energy term. The value range is [0.5, 2]. In this example, it is 1.5. i is the execution cost, J ij is the edge coupling strength, γ is the global coupling coefficient, which is used to adjust the coupling strength between task nodes, that is, the degree of influence of the dependency between tasks on the system. Its value range is [0.1, 1]. In this example, it is 0.7.ij is the edge weight of the task structure tree, which represents the strength or correlation of the edge between task nodes in the task structure tree. Its value range is [0,10] and is determined by the dependency strength between tasks. max(w) is the maximum 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 intrinsic energy term of the task node, and the non-diagonal block is the coupling relationship between nodes. The computing node load is detected in real time, the coupling coefficient of the corresponding matrix block is adjusted, and the quantum bit crosstalk is eliminated through the noise suppression factor.

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

[0119] Collect computing node resource occupancy in real time (value range is [0,1]). When the occupancy rate is greater than 0.8, reduce the computing node coupling coefficient.

[0120] Introducing noise factors The corrected coupling term is:

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

[0122] Where η is the noise factor, which introduces uncertainty and randomness as a random perturbation to avoid overfitting. The value is randomly drawn from a normal distribution with mean 0 and variance 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 quantum bit mapping table.

[0124] It should be understood that defining a binary logic variable x i ∈{0,1} represents the task node v i Whether it is selected, the quadratic unconstrained binary optimization (QUBO) matrix V is composed as follows:

[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, n is the QUBO matrix abscissa, and m is the QUBO matrix ordinate;

[0128] According to the coupler distribution of quantum annealing hardware (such as D-Wave Pegasus architecture), the binary logic variable x i Mapped to the physical quantum bit chain, if J ij ≠0, give priority to bit pairs where physical couplers exist; for coupling items that cannot be directly mapped, build a chain structure:

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

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

[0131] Among them, x i For task node v i The corresponding binary logic variable, x j For task node v j The corresponding binary logic variable, q1 is the mapping task node v i The quantum bit q2 is the mapping task node v j Quantum bit, J chain The quantum bits are strongly coupled.

[0132] S3.4: Set up a two-stage annealing strategy, quickly cool down in the coarse adjustment stage to lock the global optimal area, and slowly cool down in the fine adjustment stage to eliminate local optimal traps, and obtain the heterogeneous model combination solution through ground state interpretation.

[0133] Specifically, the two-stage annealing strategy consists of a coarse-tuning phase and a fine-tuning phase. The coarse-tuning phase runs from 0% to 50% of the time, with an initial temperature of 100 mK and exponential cooling. The goal is to quickly cross the energy barrier and lock in the global optimal region. The fine-tuning phase runs from 50% to 100% of the time, with linear cooling. The goal is to meticulously search for local optimal solutions and eliminate traps.

[0134] Read the final quantum bit state and generate a heterogeneous model combination scheme. For example, if x i =1, deploy task node v i Corresponding computing models (such as CNN, LSTM, GNN, etc.) For chain-constrained variables, majority voting is used to determine the final value.

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

[0136] Specifically, for GPU platforms, the code is converted into CUDA kernel functions and the computation graph is optimized using TensorRT. For FPGA platforms, a Verilog hardware description is generated and the logic unit is synthesized using Vivado. For CPU clusters, the code is encapsulated as an MPI task and the number of processes is dynamically allocated.

[0137] The instruction set is run in a virtualized environment to collect task completion time, resource utilization, and result accuracy. If the task completion time exceeds 20% of the expected time or the result accuracy is less than 95%, the instruction set is rolled back and re-solved.

[0138] Optimally, by mapping the static and dynamic weights of task nodes to Hamiltonian parameters, constructing a Hamiltonian matrix and dynamically adjusting the coupling coefficients, the system responds to compute node load and noise suppression in real time, ensuring process stability and accuracy. Task mapping is further optimized through QUBO matrix transformation and chain structure processing, and a two-stage annealing strategy is combined to balance global and local search to ensure a globally optimal solution. Cross-platform instruction compilation and dynamic verification mechanisms ensure efficient model operation on different hardware platforms. A rollback mechanism also optimizes task scheduling and resource allocation, improving computing resource utilization and deployment accuracy.

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

[0140] Specifically, the following steps are included:

[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, 20% is reserved as resource redundancy, the task queue capacity is 100, and the rejection policy is "discard the oldest task".

[0144] The parallel stages of the pipeline are divided into data loading (IO intensive, 2 threads are allocated), model pre-processing (CPU calculation, 2 threads are allocated) and GPU inference (asynchronous CUDA stream, 1 thread is allocated for monitoring).

[0145] The memory prefetch window size is 5, and the data of the next 5 tasks are loaded into the shared cache in advance according to the task dependencies.

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

[0147] Specifically, hardware-layer indicators include CPU utilization, GPU memory usage, and disk IOPS, with a collection frequency of 100ms and Prometheus and NodeExporter as the collection tools. Software-layer indicators include thread pool queue length, task latency, and cache hit rate, with a collection frequency of 50ms and Agent tracking as the collection tool. Business-layer indicators include task success rate, output accuracy, and data throughput, with a collection frequency triggered by task completion events and a log hook as the collection tool.

[0148] Segment aggregation refers to taking the mean, peak, and sum of indicators within a 1-second time window.

[0149] Outlier filtering refers to using the Z-score method to mark data points that deviate from the mean and perform linear interpolation to 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 lagged correlation relationships using Granger causality test, and perform confidence scoring.

[0151] It should be noted that the causal direction hardware → task indicates that resource limitations lead to task performance degradation, the causal direction task → system indicates that task accumulation causes system-level bottlenecks, and the causal direction system → hardware indicates that resource scheduling strategies affect hardware utilization.

[0152] Furthermore, the Granger causality test was performed using Python’s statsmodels library, the optimal lag order was determined using the AIC criterion, and the test statistic was calculated.

[0153] Confidence C path =1-Pvalue, 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 from the hardware layer to the task layer in the causal direction, C2 is the confidence score from the task layer to the system layer in the causal direction, C3 is the confidence score from the system layer to the hardware layer in the causal direction, and Pvalue is the p-value of the path.

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

[0157] Specifically, regular expressions are used to organize execution logs, columnar storage (Parquet format) + LZ4 compression is used, and the logs are stored in a MySQL database.

[0158] Optimally, thread pools and pipeline parallelism are utilized to optimize task execution, and memory prefetching is used to reduce data transmission latency, ensuring efficient computing. Multi-dimensional metrics are collected from the hardware, software, and business layers, and accurate performance data is provided through segmented aggregation and outlier filtering. A three-layer causal graph correlation matrix is ​​constructed and Granger causality tests are performed to analyze the lagged correlations between layers, providing data support for optimization. Confidence scores are used to assess the reliability of causal relationships. Short-term execution logs are organized, and data access efficiency is improved through compression and columnar storage, facilitating subsequent analysis and tuning.

[0159] S5: Integrate short-term execution logs through neural Turing machines, call edge computing nodes for distributed knowledge extraction, generate multimodal interpretable reports and update long-term memory libraries.

[0160] Specifically, the following steps are included:

[0161] S5.1: Extract short-term execution log fields using regular expressions, use the whole-word mask-based bidirectional self-attention mechanism to process sequence data encoder representation (BERT-wwm) model to generate semantic vectors for unstructured log text, and build a keyword inverted index.

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

[0163] The top 20 keywords are selected based on term frequency-inverse document frequency (TF-IDF) and keyword mapping is constructed.

[0164] S5.2: Construct a neural Turing machine memory matrix. The time dimension stores log fields in minute slices, the semantic dimension stores semantic vectors, and the association dimension establishes the event causal chain.

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

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

[0167] S5.3: Establish dual-channel read / write heads. The coarse-grained read head locates relevant time slices, and the fine-grained read head extracts specific event features. CAS atomic operations are used for anti-collision 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 relevant 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 correlation 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: Build 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 high-frequency IF-THEN 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] Causal chains are extracted from multimodal interpretable reports. If they occur three times in a row and the confidence level increases, they are written into the rule base. For abnormal scenarios, system snapshots (including indicators, logs, and causal diagrams) are saved for 5 minutes before and after.

[0177] Preferably, the BERT-wwm model is used to extract semantic vectors of unstructured logs, build a memory matrix and organize it by time, semantics and causal chain, realize efficient event retrieval through dual-channel read and write heads, avoid distributed write conflicts, divide the memory matrix into logical shards and distribute them to edge nodes, conduct time series pattern mining and causal analysis, generate explainable reports, update the long-term memory library based on the reports, solidify high-frequency causal chains, store abnormal scenarios and tuning history, thereby improving the intelligence and automation level of the solution and continuously optimizing decision-making capabilities.

[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, using a quantum annealing-inspired feature encoder to generate dynamic feature vectors, updating a weight matrix, and outputting a standardized feature tensor; a structure generation module for constructing a task state probability graph model based on the standardized feature tensor, using a Bayesian optimization algorithm to calculate the expected utility value of the path, projecting the high-level task space into the Koopman space, and generating a weighted task structure tree using a Monte Carlo tree search framework; an instruction acquisition module for constructing a Hamiltonian matrix based on the task structure tree, solving a heterogeneous model combination scheme using a quantum annealing simulator, and generating a model deployment instruction set; a log collation 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; and a memory update module for integrating short-term execution logs using a neural Turing machine, calling edge computing nodes for distributed knowledge extraction, generating multimodal interpretable reports, and updating the long-term memory library.

[0179] This embodiment further provides a computer device suitable for use in a multi-stage task processing method based on an intelligent agent model, comprising: 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 an intelligent agent model as proposed in the above embodiment.

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

[0181] This embodiment also provides a storage medium having a computer program stored thereon. When the program is executed by a processor, the processor implements the multi-stage task processing method based on the intelligent agent model 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 read-only memory (PROM), read-only memory (ROM), magnetic memory, flash memory, magnetic disk or optical disk.

[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 efficient fusion and real-time feature extraction of multi-source heterogeneous data, providing high-quality data input for subsequent task modeling. A task state probabilistic graph model is constructed based on a standardized feature tensor. Combining Bayesian optimization and Koopman space dimensionality reduction, a weighted task structure tree is generated through Monte Carlo tree search, accurately modeling inter-task dependencies and state transitions, achieving optimized task scheduling and resource allocation. A quantum annealing simulator is used to solve heterogeneous model combination schemes and generate model deployment instruction sets, effectively resolving the local optimality problem in high-dimensional task scheduling and ensuring rational resource allocation. Multi-threaded asynchronous computing is initiated, execution state data is collected in real time, and a causal graph model is constructed. The execution result matrix with confidence scores is output, improving the stability and reliability of task execution. Short-term execution logs are integrated through a neural Turing machine, and distributed knowledge extraction is performed using edge computing nodes. Multimodal interpretable reports are generated and long-term memory is updated, enhancing the solution's autonomous learning and continuous optimization capabilities.

[0183] It should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to limit the present invention. Although the present invention has been described in detail with reference to the preferred embodiments, those skilled in the art should understand that the technical solutions of the present invention may be modified or replaced by equivalents without departing from the spirit and scope of the technical solutions of the present invention, which should all be included in the scope of the claims of the present invention.

Claims

1. A multi-stage task processing method based on an intelligent agent model, characterized by: include, Collect heterogeneous data streams through distributed sensor networks, use quantum annealing-inspired feature encoders to generate dynamic feature vectors, update weight matrices, and output normalized feature tensors; A task state probabilistic graph model is constructed based on the standardized feature tensor. The expected utility value of the path is calculated using the Bayesian optimization algorithm. The high-level task space is projected into the Koopman space, and a weighted task structure tree is generated using the Monte Carlo tree search framework. Construct the Hamiltonian matrix based on the task structure tree, solve the heterogeneous model combination scheme through the quantum annealing simulator, and generate the model deployment instruction set; Start multi-threaded asynchronous computing, collect execution status data in real time, build a causal graph model, output an execution result matrix with confidence scores, and obtain short-term execution logs; Through the neural Turing machine, short-term execution logs are integrated, edge computing nodes are called for distributed knowledge extraction, multimodal interpretable reports are generated, and long-term memory libraries are updated.

2. The multi-stage task processing method based on the intelligent agent model according to claim 1, characterized in that: The heterogeneous data stream includes 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, characterized in that: The method collects heterogeneous data streams through a distributed sensor network, uses a quantum annealing-inspired feature encoder to generate dynamic feature vectors, updates the weight matrix, and outputs a standardized feature tensor. The specific steps are: Deploy distributed sensor arrays, connect them through network protocols, and install heterogeneous computing units; Temporally synchronize and spatially register the sensor array, apply a sliding window mechanism to detect outliers, and perform data cleaning; Extract low-level features from millimeter-wave radar signals, point cloud data, and visual data and integrate them into a feature weight matrix; Initialize the feature weight matrix to a fully connected state, break through the local optimum through the quantum tunneling effect, perform cross-dimensional weight reorganization, and simulate the quantum annealing process; Establish a dual-channel feedback loop through data-driven and task-driven methods to dynamically update weights; Modal feature normalization is performed on the feature weight matrix, and cross-modal tensor fusion is performed. Quality assessment and compensation are also performed simultaneously to output a standardized feature tensor.

4. The multi-stage task processing method based on the intelligent agent model according to claim 3, characterized in that: The task state probability graph model is constructed based on the standardized feature tensor, the expected utility value of the path is calculated using the Bayesian optimization algorithm, the high-level task space is projected into the Koopman space, and a weighted task structure tree is generated through the Monte Carlo tree search framework. The specific steps are as follows: A Bayesian network-based task state probability graph model is constructed by normalizing the feature tensor. The nodes represent the task states, and the edge weights calculate the state transition probability through a sliding window. Define a composite utility function, calculate the expected utility value of each path based on the task state probability graph model, and update it through Bayesian optimization to maximize the expected utility value; Use the Koopman operator method to construct the observation function dictionary of the high-dimensional task space and retain the front principal components to achieve dimensionality reduction projection; Monitor the rate of change of projection residuals in real time and trigger feature dictionary updates based on the residuals; 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.

5. The multi-stage task processing method based on the intelligent agent model according to claim 4, characterized in that: The Hamiltonian matrix is ​​constructed according to the task structure tree, the heterogeneous model combination scheme is solved by the quantum annealing simulator, and the model deployment instruction set is generated. The specific steps are: Perform semantic analysis on the task structure tree and map node weights to Hamiltonian parameters; Construct the Hamiltonian matrix. The main diagonal block uses the task node intrinsic energy term, and the off-diagonal block is the coupling relationship between nodes. The computing node load is detected in real time, the coupling coefficient of the corresponding matrix block is adjusted, and the quantum bit crosstalk is eliminated through the noise suppression factor. Decompose the Hamiltonian matrix into a quadratic unconstrained binary optimization problem and generate a quantum bit mapping table; A two-stage annealing strategy is set up, with rapid cooling in the coarse adjustment stage to lock the global optimal region, and slow cooling in the fine adjustment stage to eliminate local optimal traps, and a heterogeneous model combination solution is obtained through ground state interpretation; Based on the heterogeneous model combination solution, cross-platform instruction compilation is performed, dynamic verification is implemented, and a model deployment instruction set is generated.

6. The multi-stage task processing method based on the intelligent agent model according to claim 5, characterized in that: The specific steps of starting multi-threaded asynchronous computing, collecting execution status data in real time and building a causal graph model, outputting an execution result matrix with confidence scores, and obtaining short-term execution logs are as follows: Translate the model deployment instruction set, create a thread pool, and perform multi-threaded asynchronous optimization calculations through pipeline parallelism and memory prefetching mechanisms; Collect hardware, software, and business layer metrics, perform segmented aggregation, and filter outliers; Construct a three-layer causal graph correlation matrix for the hardware layer, task layer, and system layer, use the Granger causality test to perform lagged correlation relationships, and perform confidence scoring; Organize 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, characterized in that: The neural Turing machine is used to integrate short-term execution logs, call edge computing nodes for distributed knowledge extraction, generate multimodal interpretable reports and update long-term memory banks. The specific steps are: We use regular expressions to extract short-term execution log fields, use the BERT-wwm model to generate semantic vectors for unstructured log text, and build a keyword inverted index. Construct a neural Turing machine memory matrix, with the time dimension slicing and storing log fields by minute, the semantic dimension storing semantic vectors, and the association dimension establishing an event causal chain; Establish a dual-channel read / write head. The coarse-grained read head locates the relevant time slices, and the fine-grained read head extracts specific event features. CAS atomic operations are used for anti-collision writing. 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; Build a three-level knowledge system for the long-term memory library. The rule library solidifies the high-frequency causal chain, the case library stores abnormal scenarios, and the experience library records the parameter tuning history. The long-term memory library is updated based on multimodal interpretable reports.

8. A multi-stage task processing system based on an intelligent agent model, based on the multi-stage task processing method based on an intelligent agent model according to any one of claims 1 to 7, characterized in that: Including data acquisition module, structure generation module, instruction acquisition module, log sorting module and 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 standardized feature tensor, calculate the expected utility value of the path using the Bayesian optimization algorithm, project the high-level task space into the Koopman space, and generate a weighted task structure tree using the 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 the quantum annealing simulator, and generate a model deployment instruction set; The log collating module is used to start multi-threaded asynchronous computing, collect execution status data in real time and build a causal graph model, output an execution result matrix with confidence scores, and obtain short-term execution logs; The memory update module is used to integrate short-term execution logs through the neural Turing machine, call edge computing nodes for distributed knowledge extraction, generate multimodal interpretable reports and update the long-term memory library.

9. A computer device comprising a memory and a processor, wherein the memory stores a computer program, wherein: 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 a 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