Task processing method and device, electronic equipment, storage medium and program product

Abstract

Embodiments of the present application provide a task processing method and device, electronic equipment, storage medium and program product. It relates to the technical field of artificial intelligence. The method comprises: in response to receiving a to-be-processed task, analyzing the to-be-processed task to obtain multi-dimensional feature data and context information of the to-be-processed task; determining a task segmentation strategy based on the multi-dimensional feature data, and dividing the to-be-processed task into multiple sub-tasks according to the task segmentation strategy; determining the dependency relationship between the multiple sub-tasks, and executing the multiple sub-tasks according to the execution order indicated by the dependency relationship according to the context information to generate task result data corresponding to the to-be-processed task. The method combines the analysis of the multi-dimensional features of the characters with the context injection, realizes the intelligent decomposition and collaborative execution of complex tasks, and improves the processing efficiency and result reliability of complex tasks under the premise of guaranteeing semantic consistency.

Description

Technical Field

[0001] This application relates to the field of artificial intelligence technology, and in particular to a task processing method, apparatus, electronic device, storage medium, and program product. Background Technology

[0002] With the rapid development of artificial intelligence technology, the demand for automated processing of comprehensive and complex tasks is increasing. To improve processing efficiency, intelligent agents typically need to decompose tasks after receiving them, breaking down complex tasks into multiple subtasks that can be executed in parallel. Therefore, how to efficiently and reasonably decompose tasks has become a key bottleneck restricting system performance.

[0003] In related technologies, when decomposing tasks, intelligent agents simply split the tasks based on their nodes and directly assign the subtasks to multiple execution environments for processing.

[0004] However, the above methods lack quantitative analysis of the task's internal structure, leading to uneven subtask loads, frequent execution conflicts, and reduced processing efficiency. Furthermore, the inability of each execution environment to obtain global context information during execution results in semantic inconsistency in the processing results, severely impacting the reliability of task processing. Summary of the Invention

[0005] This application provides a task processing method, apparatus, electronic device, storage medium, and program product. By analyzing the multidimensional features of a person and combining them with context injection, it achieves intelligent decomposition and collaborative execution of complex tasks, improving the processing efficiency and reliability of results for complex tasks while ensuring semantic consistency.

[0006] Firstly, embodiments of this application provide a task processing method.

[0007] In response to receiving a task to be processed, the task to be processed is parsed to obtain multidimensional feature data and context information of the task to be processed;

[0008] Based on the multidimensional feature data, a task segmentation strategy is determined, and the task to be processed is segmented into multiple sub-tasks according to the task segmentation strategy.

[0009] Determine the dependencies between the multiple subtasks, and execute the multiple subtasks in the execution order indicated by the dependencies according to the context information, so as to generate task result data corresponding to the task to be processed.

[0010] This method is applied to intelligent agents. Upon receiving a task, the agent parses it to obtain multi-dimensional feature data and contextual information, thereby establishing a quantitative understanding of the task's internal structure and global semantics. Based on the multi-dimensional feature data, it determines a task segmentation strategy to achieve reasonable task decomposition, avoiding uneven sub-task loads and frequent execution conflicts, thus improving processing efficiency. Furthermore, based on the obtained sub-task dependencies, contextual information guides each sub-task to execute collaboratively according to its dependency order, generating task result data. This improves the reliability of complex task processing results while ensuring semantic consistency.

[0011] In one possible implementation, the task to be processed is parsed to obtain multidimensional feature data and contextual information of the task to be processed, including:

[0012] The task to be processed is parsed to obtain the task scenario and intermediate representation data of the task to be processed.

[0013] Based on the task scenario and the intermediate representation data, multidimensional feature data and context information of the task to be processed are generated.

[0014] In the above approach, the task to be processed is parsed to obtain the task scenario and intermediate representation data, and multi-dimensional feature data and contextual information are generated accordingly, achieving a quantitative understanding of the task's internal structure and global semantics. Specifically, using a directed graph structure with attributes as the intermediate representation data accurately characterizes the smallest semantic unit of the task and its logical, data, and semantic relationships, providing a clear and information-rich data foundation for subsequent task segmentation and execution. Furthermore, by flexibly employing various methods, such as separate extraction or ensemble algorithms, to obtain multi-dimensional feature data and contextual information, the adaptability and robustness of the solution to different task types and scenarios are improved, thereby effectively enhancing the rationality of task segmentation and the orderly execution of tasks in subsequent steps.

[0015] In one possible implementation, multidimensional feature data of the task to be processed is generated based on the intermediate representation data and the task scenario, including:

[0016] Based on the task scenario, determine the corresponding feature extraction algorithm;

[0017] Based on the feature extraction algorithm and the intermediate representation data, feature extraction is performed to obtain the multidimensional feature data of the task to be processed.

[0018] In the above approach, by adaptively matching the feature extraction algorithm according to the task scenario and combining it with structured intermediate representation data for multi-dimensional feature extraction, the relevance and accuracy of feature extraction can be improved.

[0019] In one possible implementation, the intermediate representation data is directed graph data; the directed graph data includes task node data, associated edge data, and node attribute data;

[0020] Based on the intermediate representation data and the task scenario, context information for the task to be processed is generated, including:

[0021] Based on the pre-acquired context extraction algorithm and combined with the node attribute data, context extraction is performed to obtain the context information of the task to be processed.

[0022] Through the above optional implementation methods, the intelligent agent can simultaneously acquire rich contextual information while extracting multi-dimensional feature data, thereby achieving a comprehensive understanding of the task and effectively improving the orderliness and reliability of task execution in subsequent steps.

[0023] In one possible implementation, determining a task segmentation strategy based on the multidimensional feature data includes:

[0024] Based on the preset strategy reasoning algorithm and combined with the multidimensional feature data, strategy reasoning is performed to obtain N initial segmentation strategies; where N is a positive integer greater than or equal to 2.

[0025] Determine the strategy score of each initial segmentation strategy, and determine the initial segmentation strategy with the highest strategy score as the task segmentation strategy.

[0026] Through the above optional implementation methods, the intelligent agent can automatically generate and select the most suitable segmentation strategy for the current task scenario based on multi-dimensional feature data through strategy reasoning and scoring screening mechanisms, thereby effectively improving the rationality and execution efficiency of task segmentation.

[0027] In one possible implementation, determining the strategy score for each of the initial segmentation strategies includes:

[0028] Obtain historical tasks that match the task to be processed;

[0029] Based on the task processing data of the historical tasks, each of the initial segmentation strategies is scored to obtain a strategy score for each initial segmentation strategy.

[0030] The above implementation method, by introducing historical task processing experience to score and screen the initial segmentation strategy, can make full use of the execution effect information of historical successful cases, quantitatively evaluate the candidate strategies, so that the selected task segmentation strategy not only has theoretical rationality, but has also been verified by historical practice data, thereby reducing the blindness of strategy selection and trial and error costs, and improving the efficiency and success rate of task segmentation and execution.

[0031] In one possible implementation, the task partitioning strategy includes: parallelism suitability, recommended parallelism, partitioning pattern identifier, and confidence level; wherein,

[0032] The parallelism suitability is used to assess whether a task is suitable for parallel processing.

[0033] The recommended parallelism is used to determine the optimal number of subtasks;

[0034] The partitioning mode identifier is used to indicate the specific partitioning strategy;

[0035] The confidence level is used to indicate the reliability of the prediction result.

[0036] In the above implementation, the partitioning strategy is output in the form of structured data including parallel suitability, recommended parallelism, partitioning pattern identifier and confidence level. This not only provides clear guiding parameters for subsequent task partitioning and execution, but also provides a quantitative assessment of the strategy's reliability, thereby enhancing the transparency and interpretability of the task partitioning process.

[0037] In one possible implementation, the task to be processed is divided into multiple sub-tasks according to the task segmentation strategy, including:

[0038] Based on the partitioning pattern identifier, the corresponding segmentation algorithm is determined;

[0039] Based on the segmentation algorithm and the task segmentation strategy, the task to be processed is segmented to obtain multiple sub-tasks.

[0040] In the above implementation, the agent automatically determines and calls the corresponding segmentation algorithm based on the partitioning mode identifier in the task segmentation strategy, and accurately segments the task to be processed by combining parameters such as recommended parallelism, thereby transforming abstract strategy information into executable sub-tasks and improving the overall execution efficiency and reliability of the task.

[0041] In one possible implementation, after obtaining the task scenario and intermediate representation data of the task to be processed, the method further includes:

[0042] Based on the intermediate representation data, a directed acyclic graph corresponding to the task to be processed is constructed; wherein, the directed acyclic graph is used to represent the dependency relationship between each of the subtasks and the task execution tracing chain.

[0043] The above implementation method, by synchronously constructing a directed acyclic graph corresponding to the tasks to be processed, can clearly depict the dependencies between each subtask and form a complete task execution tracing chain. This allows for accurate differentiation between subtasks that can be executed in parallel and those that must be executed serially during the task segmentation stage. During the task execution stage, it enables automated dispatching and efficient scheduling of subtasks based on dependencies and real-time status, effectively improving the efficiency of parallel task execution.

[0044] In one possible implementation, the plurality of subtasks are executed in the execution order indicated by the dependency relationship to generate task result data corresponding to the task to be processed, including:

[0045] Based on the directed acyclic graph, a preset scheduling algorithm is used to cyclically select ready subtasks from the directed acyclic graph until all subtasks are selected and executed; wherein, the ready subtasks are subtasks whose prerequisites have been satisfied.

[0046] The selected subtasks in the ready state are grouped and dispatched to the execution environment of the current agent, and the context information is injected into the execution environment of each subtask when dispatching each subtask.

[0047] After each of the subtasks is completed, the subtask data corresponding to each subtask is obtained from the execution environment;

[0048] Based on the aforementioned dependencies, the data of each subtask are aggregated to obtain the task result data corresponding to the task to be processed.

[0049] The above implementation method, through a collaborative mechanism based on directed acyclic graphs and scheduling algorithms, achieves automated selection, grouping and dispatching, context injection, data collection and result aggregation of subtasks, thereby maximizing parallel execution efficiency and resource utilization while ensuring the correctness of dependencies.

[0050] In one possible implementation, after generating the task result data corresponding to the task to be processed, the method further includes:

[0051] The task processing data of the task to be processed is stored in the historical task database; wherein, the task processing data is used as historical task data to participate in the scoring of the task segmentation strategy in the subsequent task processing process.

[0052] Through the above implementation method, the task processing data generated during each task processing can be persistently stored and fed back as historical task data to the subsequent task segmentation strategy scoring stage, realizing the accumulation and reuse of task processing experience, thereby continuously optimizing the overall efficiency of task segmentation and execution.

[0053] Secondly, embodiments of this application provide a task processing apparatus, including:

[0054] The task parsing module is used to parse the task to be processed in response to receiving the task to be processed, so as to obtain the multidimensional feature data and context information of the task to be processed;

[0055] The task segmentation module is used to determine a task segmentation strategy based on the multidimensional feature data, and to segment the task to be processed into multiple sub-tasks according to the task segmentation strategy.

[0056] The task execution module is used to determine the dependencies between the multiple subtasks, and execute the multiple subtasks in the execution order indicated by the dependencies according to the context information, so as to generate task result data corresponding to the task to be processed.

[0057] Thirdly, embodiments of this application provide an electronic device, including: a memory and a processor;

[0058] The memory stores computer-executed instructions;

[0059] The processor executes computer execution instructions stored in the memory, causing the processor to perform the first aspect and / or various possible implementations of the first aspect as described above.

[0060] Fourthly, embodiments of this application provide a computer-readable storage medium storing computer-executable instructions, which, when executed by a processor, are used to implement the first aspect and / or various possible implementations of the first aspect.

[0061] Fifthly, embodiments of this application provide a computer program product, including a computer program that, when executed by a processor, implements the first aspect and / or various possible implementations of the first aspect.

[0062] The task processing method, apparatus, electronic device, storage medium, and program product provided in this application parsingly obtain multi-dimensional feature data and contextual information for the task to be processed, thereby achieving a quantitative understanding of the task's internal structure and global semantics. Then, based on the multi-dimensional feature data, a task segmentation strategy is determined, rationally dividing complex tasks into multiple sub-tasks. This avoids the problems of uneven sub-task load and frequent execution conflicts caused by simple splitting in existing technologies, thus improving task processing efficiency. Furthermore, by determining the dependencies between sub-tasks and combining contextual information to execute each sub-task in an orderly manner according to the dependency order, it ensures that each execution environment works collaboratively while sharing a global context, effectively avoiding information silos and result conflicts. Therefore, while ensuring semantic consistency, the reliability of complex task processing results is improved. Attached Figure Description

[0063] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with this application and, together with the description, serve to explain the principles of this application.

[0064] Figure 1 A schematic diagram of a task processing method provided in an embodiment of this application;

[0065] Figure 2 A flowchart illustrating a task processing method provided in an embodiment of this application;

[0066] Figure 3 A flowchart illustrating another task processing method provided in this application embodiment.

[0067] Figure 4 A schematic diagram of the task processing unit provided in this application;

[0068] Figure 5 A schematic diagram of the structure of the electronic device provided in this application.

[0069] The accompanying drawings illustrate specific embodiments of this application, which will be described in more detail below. These drawings and descriptions are not intended to limit the scope of the concept in any way, but rather to illustrate the concept of this application to those skilled in the art through reference to particular embodiments. Detailed Implementation

[0070] Exemplary embodiments will now be described in detail, examples of which are illustrated in the accompanying drawings. When the following description relates to the drawings, unless otherwise indicated, the same numbers in different drawings denote the same or similar elements. The embodiments described in the following exemplary embodiments do not represent all embodiments consistent with this application. Rather, they are merely examples of apparatuses and methods consistent with some aspects of this application as detailed in the appended claims.

[0071] The collection, storage, use, processing, transmission, provision, and disclosure of financial data or user data involved in the technical solution of this application all comply with the provisions of relevant laws and regulations and do not violate public order and good morals.

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

[0073] It should be noted that in the embodiments of this application, certain software, components, models and other existing solutions in the industry may be mentioned. These should be regarded as exemplary and are only intended to illustrate the feasibility of implementing the technical solution of this application. However, it does not mean that the applicant has used or necessarily used the solution.

[0074] With the rapid development of artificial intelligence technology, the demand for automated processing of comprehensive and complex tasks is increasing. To improve processing efficiency, intelligent agents typically need to decompose tasks after receiving them, breaking down complex tasks into multiple subtasks that can be executed in parallel. Therefore, how to efficiently and reasonably decompose tasks has become a key bottleneck restricting system performance.

[0075] In related technologies, when decomposing tasks, intelligent agents simply split the tasks based on their nodes and directly assign the subtasks to multiple execution environments for processing.

[0076] However, the above methods lack quantitative analysis of the task's internal structure, leading to uneven subtask loads, frequent execution conflicts, and reduced processing efficiency. Furthermore, the inability of each execution environment to obtain global context information during execution results in semantic inconsistency in the processing results, severely impacting the reliability of task processing.

[0077] To address the aforementioned technical problems, this application provides a task processing method. This method is applied to an intelligent agent. Upon receiving a task to be processed, the agent parses it to obtain multi-dimensional feature data and contextual information, thereby establishing a quantitative understanding of the task's internal structure and global semantics. Then, based on the multi-dimensional feature data, a task segmentation strategy is determined to achieve reasonable task decomposition, avoiding uneven sub-task loads and frequent execution conflicts, thus improving processing efficiency. Furthermore, based on the obtained sub-task dependencies, contextual information is used to guide each sub-task to execute collaboratively according to its dependency order, generating task result data. This improves the reliability of complex task processing results while ensuring semantic consistency.

[0078] The task processing method provided in this application is applicable to various scenarios in which multiple execution environments are deployed in a single intelligent body to collaboratively complete complex tasks.

[0079] For example, in an intelligent customer service system, after receiving a user's inquiry, the agent needs to simultaneously perform multiple sub-tasks such as intent recognition, knowledge base retrieval, script generation, and sentiment analysis. This method allows the agent to parse and rationally divide the task, allocating different sub-tasks to multiple internal execution environments, and executing them in an orderly manner based on dependencies. This ensures that each execution environment works collaboratively while sharing global context information, ultimately generating consistent and accurate customer service responses.

[0080] Furthermore, the above method can also be applied to intelligent document processing scenarios, such as contract review tasks. The intelligent agent needs to simultaneously perform sub-tasks such as clause extraction, compliance checks, risk labeling, and summary generation. This method can decompose the tasks and distribute them to different execution environments for parallel processing, and use contextual information to guide each execution environment to execute in the order of dependencies, avoiding information silos and result conflicts.

[0081] In summary, any scenario in which a single intelligent agent needs to collaboratively process complex tasks through multiple execution environments and ensure semantic consistency between the execution environments falls under the application scenarios of the task processing technology solution in this application.

[0082] The following is combined with Figure 1 The application scenarios applicable to the embodiments of this application are described below. Figure 1 This is a diagram illustrating an application scenario of the task processing method provided in this application.

[0083] See Figure 1 In any of the above scenarios, such as in an intelligent customer service scenario, the task processing method provided in this application embodiment relates to an intelligent agent. This intelligent agent deploys multiple execution environments to perform different sub-tasks such as intent recognition, knowledge base retrieval, script generation, and sentiment analysis. The execution environments collaborate by sharing context information and determine the execution order based on the dependencies between sub-tasks.

[0084] Based on this, the task processing method provided in this application generally includes the following:

[0085] After receiving a user's inquiry task, the intelligent agent parses the task and obtains multi-dimensional feature data and contextual information;

[0086] Based on multidimensional feature data, a task segmentation strategy is determined, and user consultation tasks are reasonably divided into multiple sub-tasks such as intent recognition, knowledge base retrieval, script generation, and sentiment analysis.

[0087] Determine the dependencies between subtasks; for example, intent recognition needs to be completed before knowledge base retrieval, and sentiment analysis results can be used for tone adjustment during the speech generation stage.

[0088] Based on context information and in accordance with the execution order indicated by dependencies, the agent assigns each subtask to the corresponding execution environment for execution;

[0089] After each execution environment completes its subtask, it outputs the corresponding subtask result data.

[0090] The agent aggregates the subtask results data from each execution environment and generates the final user response.

[0091] In the above steps, multi-dimensional feature data and context information are obtained through parsing, and task segmentation and dependency-driven ordered execution are performed accordingly. This achieves improved processing efficiency and result reliability of complex tasks while ensuring global semantic consistency.

[0092] The technical solution of this application and how the technical solution of this application solves the above-mentioned technical problems are described in detail below with specific embodiments. These specific embodiments can be combined with each other, and the same or similar concepts or processes may not be described again in some embodiments. The embodiments of this application will be described below with reference to the accompanying drawings.

[0093] Figure 2 Flowchart of the task processing method provided in this application Figure 1 This method can be executed by a task processing device, which can be a server or an electronic device; the following explanation uses an electronic device as an example. The method in this embodiment can be implemented through software, hardware, or a combination of both. Figure 2 As shown, the method includes:

[0094] S201. In response to receiving a task to be processed, the task to be processed is parsed to obtain multidimensional feature data and context information of the task to be processed.

[0095] In this embodiment, the task to be processed is a comprehensive and complex task that a single intelligent agent needs to complete through the collaboration of multiple internal execution environments. Its form can be flexibly changed according to the specific application scenario. For example, in the intelligent customer service scenario, it can be a user consultation task; in the intelligent document processing scenario, it can be a contract review task; in the marketing scenario, it can be a marketing strategy generation task; and in the reasoning scenario, it can be a logical reasoning task, etc.

[0096] As the core entity for task processing, the intelligent agent needs to monitor the task receiving channel in real time. When it detects an externally sent task to be processed, such as a user's consultation request submitted through the terminal or an automatically processed task triggered by the system, it immediately triggers the parsing process of this step to ensure the timeliness of task processing.

[0097] Specifically, intelligent agents can extract multi-dimensional features from task descriptions using pre-built natural language processing models, rule engines, or machine learning algorithms to quantitatively analyze the task's structural complexity, resource requirements, and processing difficulty. These multi-dimensional feature data include at least one or more of the following: task type features, used to identify the task's category, such as consultation, review, or generation; task complexity features, used to quantify the task's logical depth, number of branches, or scale of required processing steps, for example, by calculating key verbs, the number of entities, or logical connectors in the task description; resource requirement features, used to analyze the task's potential demand for computing resources (such as CPU, memory, GPU), data resources, or time resources; and semantic association features, used to identify the degree of semantic association between different entities, intentions, or operations in the task, providing a basis for subsequent task segmentation.

[0098] The intelligent agent not only analyzes the task itself but also proactively acquires global contextual information related to the current task. This contextual information ensures semantic consistency in the execution results of each subtask, avoiding information silos. Contextual information includes at least one or more of the following: task history information (i.e., if the current task is part of a process, previous interaction records, historical processing results, or user profile data are acquired); global configuration information (i.e., system-preset rules, strategies, preference settings, or domain knowledge graphs are acquired); environmental status information (i.e., real-time information such as the load status, available resources, and network conditions of each execution environment); and, in some scenarios, user intent and emotional information can also be acquired. For example, in intelligent customer service scenarios, the user's true intent and emotional tendencies are extracted from the task description, and this information serves as important input for subsequent subtasks.

[0099] It should be noted that the parsing process in this step also has adaptive adjustment capabilities, dynamically adjusting the parsing strategy according to the type and complexity of the task to be processed. For example, for simple and low-complexity tasks, the parsing process can be simplified to quickly extract its multi-dimensional features and contextual information; for high-complexity, multi-related tasks, a deep parsing mode can be activated to further increase the dimensions of feature extraction and the coverage of contextual information, ensuring that the parsing results can fully support subsequent task processing. In addition, anomaly detection is performed during the parsing process. If any issues such as missing information or format errors are detected in the task to be processed, timely feedback will be provided and a supplementary request will be triggered to ensure the integrity of the parsed data and improve the reliability of task processing.

[0100] The intelligent agent transforms the original, unstructured tasks into a set of structured, quantifiable, multi-dimensional feature data and rich contextual information. This provides a data foundation for subsequent steps to achieve scientific and reasonable task segmentation and orderly, collaborative execution of subtasks. It overcomes the shortcomings of existing technologies that simply split tasks based on task nodes and lack quantitative analysis and a global perspective, thereby improving the efficiency of task processing and the reliability of results.

[0101] S202. Based on multidimensional feature data, determine the task segmentation strategy and divide the task to be processed into multiple sub-tasks according to the task segmentation strategy.

[0102] After acquiring the multidimensional feature data of the task to be processed, the agent further utilizes this feature data to dynamically determine a task splitting strategy that matches the task through a preset decision model or rule engine. In this embodiment, the splitting strategy is used to achieve load balancing among subtasks, reduce execution conflicts, and maximize parallel processing efficiency, thereby overcoming the technical problem of low task processing efficiency caused by simply splitting tasks based on task nodes in the prior art.

[0103] Specifically, the intelligent agent performs comprehensive analysis of multi-dimensional feature data. For example, it assesses the overall scale and logical depth of the task based on task complexity features to determine the granularity of segmentation; it judges the dependence of each subtask on computing and data resources based on resource requirement features to avoid concentrating high-resource-demand tasks in the same execution environment; and it identifies the degree of coupling between different operations or entities in the task based on semantic association features, keeping highly coupled operations in the same subtask and splitting low-coupling operations into independent subtasks to reduce communication overhead and conflict risks during execution.

[0104] Based on the above analysis, a specific partitioning scheme is generated. This scheme includes the number of subtasks after partitioning, the functional boundaries of each subtask, and the preliminary dependencies between the subtasks. For example, for tasks with high complexity, diverse resource requirements, and loose semantic relationships, the agent tends to adopt a fine-grained partitioning strategy, splitting them into multiple parallel executable subtasks; for tasks with lower complexity and tighter semantic relationships, a coarse-grained partitioning strategy is adopted to reduce the number of partitions and thus reduce scheduling overhead.

[0105] Based on the determined task segmentation strategy, the task to be processed is actually divided into multiple subtasks. Each subtask contains a clear execution goal, input parameters, and expected output, and carries context information inherited from the original task so that the global context can be shared during subsequent execution.

[0106] The above approach, through quantitative analysis and dynamic decision-making based on multidimensional feature data, makes task segmentation more scientific and reasonable, effectively avoiding the problems of uneven subtask load and frequent execution conflicts, facilitating the efficient and orderly execution of each subtask and improving task processing efficiency.

[0107] S203. Determine the dependencies between multiple subtasks, and execute the multiple subtasks in the order indicated by the dependencies according to the context information, so as to generate the task result data corresponding to the task to be processed.

[0108] After dividing the task to be processed into multiple subtasks, the agent further performs the following operations to ensure that each subtask can be executed collaboratively in a reasonable order and to generate semantically consistent task result data under the guidance of global context information.

[0109] Specifically, the agent determines the dependencies between multiple subtasks. In this embodiment, the dependencies reflect the preconditions and postconditions required for the execution of each subtask. Dependencies can be determined based on task logic dependency analysis, whereby the agent identifies which subtasks must be executed only after other subtasks are completed, based on the business process or logical sequence of the task itself. For example, in an intelligent customer service scenario, the intent recognition subtask must be completed before the knowledge base retrieval subtask, because the retrieval requires the identified intent as a query condition. Similarly, the results of the sentiment analysis subtask can be used for tone adjustment in the speech generation stage, so sentiment analysis should be completed before speech generation. Furthermore, dependencies can be determined based on data flow dependency analysis, where the agent analyzes the input-output data relationships between subtasks to identify which subtask outputs are inputs for other subtasks. For example, in a contract review scenario, the output of the clause extraction subtask is the input of the compliance check subtask, thus there is a data dependency between them. Dependencies can also be determined based on resource contention, where the agent identifies subtasks that may cause resource conflicts based on the access requirements of each subtask to shared resources, and avoids conflicts by setting execution order or locking mechanisms.

[0110] Based on this, the agent executes multiple subtasks according to the execution order indicated by the dependency relationship, based on the context information obtained in the aforementioned manner.

[0111] Specifically, the agent combines dependencies with contextual information to generate a globally ordered execution plan. This execution plan clarifies which subtasks can be executed in parallel (i.e., subtasks without dependencies) and which subtasks must be executed sequentially (i.e., subtasks with dependencies).

[0112] During execution, the agent transmits contextual information as shared data to each execution environment, ensuring that each subtask has access to globally consistent background information during execution. For example, in an intelligent customer service scenario, the script generation subtask, during execution, not only receives answer data returned by the knowledge base retrieval, but also simultaneously acquires the user's emotional state output by sentiment analysis and the user's intent output by intent recognition, thereby generating a response with appropriate tone and accurate content.

[0113] In addition, the intelligent agent monitors the execution status of each subtask in real time. When a preceding subtask is completed, it immediately triggers the execution of its subsequent subtasks, ensuring the continuity and efficiency of the execution process.

[0114] Once all subtasks have been executed according to their dependencies, the agent aggregates the subtask result data to generate the task result data corresponding to the task to be processed. It should be understood that this task result data is generated collaboratively by multiple subtasks under the guidance of global context information, thus possessing high semantic consistency and reliability. For example, in an intelligent customer service scenario, the final generated task result data is a complete, accurate, and appropriately worded user response; in a contract review scenario, the final generated task result data is a complete review report including clause extraction, compliance checks, risk labeling, and summary generation.

[0115] The task processing method provided in this embodiment parses the task to be processed to obtain multi-dimensional feature data and contextual information, achieving a quantitative understanding of the task's internal structure and global semantics. Then, based on the multi-dimensional feature data, a task segmentation strategy is determined, rationally dividing complex tasks into multiple subtasks. This avoids the problems of uneven subtask load and frequent execution conflicts caused by simple splitting in existing technologies, thus improving task processing efficiency. Furthermore, by determining the dependencies between subtasks and combining contextual information to execute each subtask in an orderly manner according to the dependency order, it ensures that each execution environment works collaboratively while sharing a global context, effectively avoiding information silos and result conflicts. Therefore, while ensuring semantic consistency, the reliability of complex task processing results is improved.

[0116] Next, the technical principles of the task processing solution of this application will be further explained. It should be noted that the following description is merely an exemplary implementation of the technical solution of this application and does not constitute any limitation on the technical solution of this application.

[0117] In this embodiment, an optional implementation of parsing the task to be processed to obtain multidimensional feature data and context information may include: parsing the task to be processed to obtain the task scenario and intermediate representation data of the task to be processed; and generating multidimensional feature data and context information of the task to be processed based on the task scenario and intermediate representation data.

[0118] When an intelligent agent parses a task to be processed, it can first extract the task scenario and intermediate representation data of the task to be processed.

[0119] In this context, the task scenario refers to the application domain or business context to which the task to be processed belongs, such as intelligent customer service scenarios, contract review scenarios, and marketing planning scenarios. Task scenario identification can be achieved through pre-defined scenario classification models or rule matching methods.

[0120] Intermediate representation data refers to the intermediate form of data generated after the task to be processed has been structured, facilitating subsequent computation and analysis. This intermediate representation data can include, but is not limited to: the task's syntax structure tree, semantic dependency graph, keyword list, entity relation triples, intent label sequences, etc. The generation of intermediate representation data can be achieved through natural language processing techniques, such as word segmentation, part-of-speech tagging, named entity recognition, dependency parsing, and semantic role labeling.

[0121] In one exemplary embodiment, the intermediate representation data is a directed graph structure data G with attributes. Here, G=(V,E,A), meaning the directed graph data G includes task node data V, associated edge data E, and node attribute data A. The task node data V represents the smallest semantic unit or operation entity in the task to be processed, such as keywords, entity names, intent labels, operation steps, etc. Each node corresponds to an independent semantic element in the task description.

[0122] The edge data E represents the logical order, data dependency, or semantic relationship between task nodes, such as sequence, input-output dependency, semantic similarity, or conditional branching. Each edge defines the connection method and interaction direction between nodes.

[0123] Node attribute data A represents the storage of metadata such as the original content, type label, and confidence score of each task node. For example, the text content of the node, its category (such as entity, action, condition), and additional attribute information extracted from the task description.

[0124] After obtaining the task scenario and intermediate representation data, the agent can further generate multi-dimensional feature data and contextual information based on these two types of information.

[0125] Specifically, various implementation methods can be used to acquire multidimensional feature data and contextual information. In one optional implementation, different extraction algorithms can be used to extract information separately, thereby obtaining multidimensional feature data and contextual information. For example, a first algorithm can be used to extract multidimensional feature data such as task complexity features, resource requirement features, and semantic association features, while a second algorithm can be used to extract contextual information such as task history information, global configuration information, environmental state information, and user intent and sentiment information. Alternatively, an ensemble algorithm can be used to simultaneously parse the task to be processed, directly obtaining multidimensional feature data and contextual information. This embodiment does not limit the specific extraction method and algorithm type, as long as the purpose of acquiring multidimensional feature data and contextual information from the task to be processed can be achieved.

[0126] In the above approach, the task to be processed is parsed to obtain the task scenario and intermediate representation data, and multi-dimensional feature data and contextual information are generated accordingly, achieving a quantitative understanding of the task's internal structure and global semantics. Specifically, using a directed graph structure with attributes as the intermediate representation data accurately characterizes the smallest semantic unit of the task and its logical, data, and semantic relationships, providing a clear and information-rich data foundation for subsequent task segmentation and execution. Furthermore, by flexibly employing various methods, such as separate extraction or ensemble algorithms, to obtain multi-dimensional feature data and contextual information, the adaptability and robustness of the solution to different task types and scenarios are improved, thereby effectively enhancing the rationality of task segmentation and the orderly execution of tasks in subsequent steps.

[0127] In the implementation of the above method, an optional implementation method for generating multidimensional data by combining intermediate representation data and task scenario is as follows: determine the corresponding feature extraction algorithm according to the task scenario; perform feature extraction according to the feature extraction algorithm and the intermediate representation data to obtain multidimensional feature data of the task to be processed.

[0128] In this embodiment, different task scenarios typically correspond to different feature focus areas and extraction strategies. The intelligent agent can match the corresponding feature extraction algorithm from a pre-set algorithm library or configuration table based on the identified task scenario. For example, if the task scenario is an intelligent customer service scenario, the corresponding feature extraction algorithm may focus on extracting the hierarchical structure features of user intent, sentiment characteristics, and contextual association features in the dialogue history. If the task scenario is a contract review scenario, the corresponding feature extraction algorithm may focus on extracting the distribution features of clause types, compliance risk features, and logical constraint features between entities. If the task scenario is a marketing planning scenario, the corresponding feature extraction algorithm may focus on extracting the target audience profile features, market trend features, and synergistic effect features between activity elements. The algorithm determination process can be implemented based on rule matching, machine learning classification models, or scenario-algorithm mapping tables; this embodiment does not limit this approach.

[0129] After determining the feature extraction algorithm, the agent takes the previously generated intermediate representation data as input and calls the algorithm to extract features.

[0130] Specifically, during the extraction process, the node attribute data A in the intermediate representation data is statistically analyzed or encoded to extract node-level features, such as the number of nodes, node type distribution, and node content length. Topological analysis is also performed on the associated edge data E to extract structural features, such as graph density, node in-degree, critical path length, and number of connected components. Furthermore, combining domain knowledge from the task scenario, semantic enhancement or pattern matching is performed on the intermediate representation data to extract semantic features, such as the frequency of occurrence of specific entity combinations and the confidence level of specific relationship patterns, to obtain multi-dimensional feature data T=[t1,t2,…,t…]. n ]. Among them, t 1、 t2 and t n These represent features in different dimensions.

[0131] In one exemplary scenario, t1 is a structural complexity feature, which can be measured by the average degree d of the graph and the clustering coefficient C.

[0132] Here, the average degree 'd' represents the average degree of all nodes in the graph, reflecting the overall connectivity density of the graph. For example, its calculation formula is:

[0133]

[0134] Where |V| represents the total number of nodes in the graph, and d(v) represents the degree of node v (i.e. the number of edges connected to that node).

[0135] Furthermore, the clustering coefficient C is used to measure the degree of clustering of nodes in the graph, that is, how closely the neighbors of a node are connected. For example, its calculation formula is as follows:

[0136]

[0137] Where N(v) represents the set of neighboring nodes of node v. d(v)(d(v)-1) / 2 represents the number of edges that actually exist between the neighboring nodes of node (v), and d(v)(d(v)-1) / 2 represents the maximum number of edges that may exist between the neighboring nodes of node v.

[0138] The two metrics mentioned above can quantify the complexity of the directed graph structure corresponding to the intermediate representation data at the topological level, providing structural feature basis for subsequent task segmentation strategies.

[0139] t2 can be a semantic relevance feature, which can be measured by constructing a similarity matrix S using vertex embedding representation.

[0140] For example, the expression for S can include:

[0141]

[0142] Among them, e i and e j These are the vertices v i and v j The embedding vector.

[0143] Specifically, first, for each task node v in the intermediate representation data... i Embedded representation learning is performed to obtain its corresponding low-dimensional dense vector e. i This embedding vector can capture the semantic information of nodes and their contextual relationships within the graph structure. Based on any two nodes v... i and v j Embedded vector e i and e j The semantic similarity between the two is calculated using a similarity calculation function, thereby constructing a similarity matrix S. The similarity calculation function can be implemented using cosine similarity, Euclidean distance, Pearson correlation coefficient, or dot product similarity, etc., and this embodiment does not limit the specific method used.

[0144] By using the similarity moment = S, the semantic correlation between any two task nodes in the graph can be quantified, providing semantic feature basis for subsequent task segmentation strategies.

[0145] t n This can be a cohesion feature, which can be calculated through cross-vertex reference chains and is used to measure the degree of association between two nodes in a graph. Specifically, v i and v j The adhesion degree C can be calculated using the following expression:

[0146]

[0147] in, , indicating from node v i Pointing to node v j The set of directed edges, |R ij | indicates the number of edges in the set (i.e., node v). i to node v j The number of direct directed connections (d(v)) is typically 0 or 1, but may be greater than 1 in a polygon graph. i ) represents node v i The out-degree, i.e., from node v i The total number of edges originating from node v and pointing to other nodes. This metric reflects the total number of edges originating from node v. i Its neighbor node v j The strength of a node's reference or dependency; a larger value indicates higher dependency on the node v. i With node v j The closer the connection between them, the higher the degree of adhesion.

[0148] By calculating the bonding strength between all node pairs in the graph, strong correlations between task nodes can be identified, providing structural coupling-level feature basis for subsequent task segmentation strategies.

[0149] In the above approach, by adaptively matching the feature extraction algorithm according to the task scenario and combining it with structured intermediate representation data for multi-dimensional feature extraction, the relevance and accuracy of feature extraction can be improved.

[0150] After parsing the task to be processed and generating intermediate representation data, the agent can not only obtain multi-dimensional feature data through feature extraction algorithms, but also extract contextual information synchronously or in parallel to fully understand the environment and background of the task.

[0151] In one optional implementation of extracting context information, the extraction process includes: extracting context based on a pre-acquired context extraction algorithm and in combination with node attribute data to obtain the context information of the task to be processed.

[0152] In this embodiment, the context extraction algorithm can be a rule-based method, a statistical model-based method, or a deep learning-based method, such as a sequence labeling model, a graph neural network encoder, or a pre-trained language model. This embodiment does not limit the specific type of context extraction algorithm, as long as it can extract background information related to task execution from the intermediate representation data.

[0153] After acquiring the context extraction algorithm, the agent takes the node attribute data A from the intermediate representation data as input and calls the algorithm to extract the context. The node attribute data A stores metadata such as the original content, type label, and confidence score of each task node, which is an important foundation for extracting context information.

[0154] After the context extraction algorithm is used for extraction processing, the agent can obtain a set of structured context information, which may include, but is not limited to: task history information, global configuration information, environmental state information, etc.

[0155] Through the above optional implementation methods, the intelligent agent can simultaneously acquire rich contextual information while extracting multi-dimensional feature data, thereby achieving a comprehensive understanding of the task and effectively improving the orderliness and reliability of task execution in subsequent steps.

[0156] Based on the multidimensional feature data obtained according to the above implementation method, a task segmentation strategy corresponding to the task to be processed can be determined based on the multidimensional data. In this embodiment, an optional implementation method for determining the task segmentation strategy may include: performing strategy reasoning according to a preset strategy reasoning algorithm and in combination with the multidimensional feature data to obtain N initial segmentation strategies; where N is a positive integer greater than or equal to 2; determining the strategy score of each initial segmentation strategy, and determining the initial segmentation strategy with the highest strategy score as the task segmentation strategy.

[0157] Specifically, the agent retrieves a policy reasoning algorithm that matches the current task scenario from a pre-set algorithm library or configuration table. This policy reasoning algorithm can be a rule-based reasoning method, a classification method based on decision trees or random forests, a policy generation method based on reinforcement learning, or a reasoning generation method based on a large language model. This embodiment does not limit the specific type of policy reasoning algorithm, as long as it can generate multiple candidate segmentation strategies based on the input multidimensional feature data.

[0158] The agent takes multi-dimensional feature data as input and calls the policy reasoning algorithm to perform reasoning calculations.

[0159] During inference, multidimensional feature data is normalized or standardized to eliminate dimensional differences between features of different dimensions. The processed feature data is then input into the policy inference algorithm. The algorithm generates multiple candidate initial segmentation strategies based on the combination relationships between features, threshold judgments, or probability distributions, ensuring that multiple initial strategies are available for comparison and selection. Each initial segmentation strategy includes a set of segmentation rules or schemes. Examples include: a set of segmentation points for dividing the task graph into several subgraphs, a task allocation scheme for each subgraph, and execution order constraints between subgraphs.

[0160] The agent scores each initial segmentation strategy. The scoring method can be weighted summation, multi-objective optimization ranking, or inference computation based on a pre-trained scoring model. This embodiment does not limit the scoring method.

[0161] The agent compares the scores of all initial segmentation strategies and determines the initial segmentation strategy with the highest score as the final task segmentation strategy. If multiple strategies have the same score, a second screening can be performed by combining preset priority rules (such as execution efficiency priority, resource balancing priority, etc.), or one of them can be randomly selected as the final strategy.

[0162] Through the above optional implementation methods, the intelligent agent can automatically generate and select the most suitable segmentation strategy for the current task scenario based on multi-dimensional feature data through strategy reasoning and scoring screening mechanisms, thereby effectively improving the rationality and execution efficiency of task segmentation.

[0163] In the above embodiments, an optional implementation of scoring any obtained initial segmentation strategy may include: obtaining historical tasks that match the task to be processed; scoring each initial segmentation strategy based on the task processing data of the historical tasks to obtain a strategy score for each initial segmentation strategy.

[0164] After obtaining N initial segmentation strategies, the agent can use its experience in handling historical tasks to score each candidate strategy in order to select the optimal strategy that has been verified in practice or that highly matches historical success cases.

[0165] Specifically, the agent retrieves historical tasks from the historical task database that match the current task. During matching, one approach is task scenario matching, which retrieves historical tasks within the same scenario as the current task; another approach is feature similarity matching, which calculates the similarity between the multidimensional feature data of the current task and the feature data of historical tasks, selecting historical tasks with a similarity higher than a preset threshold; a third approach is task identifier matching, where if the current task has a unique identifier or task number, the corresponding historical task record is directly retrieved.

[0166] Based on the acquired historical task processing data, the agent scores each of the N initial segmentation strategies generated at the moment.

[0167] When scoring, one or more of the following methods can be used: similarity matching scoring, historical performance mapping scoring, or weighted regression scoring. Similarity matching scoring calculates the similarity between the current initial segmentation strategy and historically successful segmentation strategies; higher similarity results in a higher score. Historical performance mapping scoring compares the current initial segmentation strategy with segmentation strategies used in previous tasks; if the same or highly similar strategies exist, the execution result score corresponding to that historical strategy is directly mapped as the score for the current strategy. Weighted regression scoring uses multiple performance metrics from historical task data as regression targets, takes the features of the segmentation strategy as input, trains or calls a pre-trained scoring model, and predicts a score for the current initial segmentation strategy.

[0168] The above implementation method, by introducing historical task processing experience to score and screen the initial segmentation strategy, can make full use of the execution effect information of historical successful cases, quantitatively evaluate the candidate strategies, so that the selected task segmentation strategy not only has theoretical rationality, but has also been verified by historical practice data, thereby reducing the blindness of strategy selection and trial and error costs, and improving the efficiency and success rate of task segmentation and execution.

[0169] In one optional implementation, the partitioning strategy obtained based on the aforementioned method may include parallelism suitability, recommended parallelism, partitioning pattern identifier, and confidence level; wherein, parallelism suitability is used to evaluate whether the task is suitable for parallel processing; recommended parallelism is used to determine the optimal number of subtasks; partitioning pattern identifier is used to indicate the specific partitioning strategy; and confidence level is used to represent the reliability of the prediction results.

[0170] In this embodiment, after the task segmentation strategy is determined through the aforementioned scoring mechanism or strategy reasoning process, the segmentation strategy can be represented in the form of structured data, such as Decision=(P,K,M,S), that is, the structured data contains at least the following four fields: parallel suitability P, recommended parallelism K, partitioning pattern identifier M, and confidence S.

[0171] The parallelism suitability is used to assess whether the current task is suitable for parallel processing. This field can be a binary variable (e.g., yes or no) or a continuous value (e.g., a probability value between 0 and 1), with higher values ​​indicating greater suitability for parallel processing. For example, when the parallelism suitability is higher than a preset threshold (e.g., 0.7), the agent can determine that the task is suitable for parallel partitioning; otherwise, it may use serial or hybrid processing methods. The determination of parallelism suitability can be based on factors such as task dependencies, data coupling, and computing resource availability in the multidimensional feature data.

[0172] In one exemplary embodiment, the parallel fitness P can be based on vertices v in G. iCentrality score c i Result. For example, the centrality score c. i The expression can include:

[0173]

[0174] Where α is the damping factor, typically taking the value 0.85; N(i) represents the vertex v. i The set of neighbors of vertex v; d(j) is the vertex v j The degree of |V|; |V| is the total number of vertices in the task graph G.

[0175] Optionally, after constructing the task graph G corresponding to the task to be processed, the agent can quantify the importance of each vertex in the task graph based on the centrality analysis method in graph theory, and then deduce the parallel suitability of the entire task.

[0176] Furthermore, the recommended parallelism degree K is used to determine the optimal number of subtasks to divide a task into during parallel processing. This field can be a positive integer representing the suggested number of subtasks. For example, a recommended parallelism degree of 4 means that the task is recommended to be divided into 4 subtasks for parallel execution. The determination of the recommended parallelism degree K can comprehensively consider factors such as the computational complexity of the task, the amount of available system resources, and the time constraints of task execution, in order to achieve a balance between resource utilization and execution efficiency.

[0177] The partitioning mode identifier M indicates a specific partitioning strategy or partitioning mode. Its value can be an enumeration value or an identifier, corresponding to a variety of predefined partitioning modes, including: data parallel mode, which splits the input data by dimension or batch, with each subtask processing different data fragments; task parallel mode, which splits different functional modules or computing nodes in the task graph, with each subtask performing different functions; pipeline parallel mode, which splits the task by execution stage, with each subtask processing the data flow of different stages in sequence; and hybrid parallel mode, which combines the above multiple modes for comprehensive partitioning.

[0178] The confidence level S represents the reliability or credibility of the prediction result of the current segmentation strategy. This field can take a value between 0 and 1, with a higher value indicating greater confidence from the agent in the prediction result. The confidence level can be determined based on factors such as the score differences among candidate strategies during the scoring process, the degree of matching between historical data and the current task, and the output probability distribution of the strategy inference model. For example, if the scores of multiple candidate strategies are very close, the confidence level may be low; if the score of one strategy is significantly higher than other strategies, the confidence level is high. During subsequent execution, the agent can decide whether to manually review or dynamically adjust the segmentation strategy based on the confidence level.

[0179] In the above implementation, the partitioning strategy is output in the form of structured data including parallel suitability, recommended parallelism, partitioning pattern identifier and confidence level. This not only provides clear guiding parameters for subsequent task partitioning and execution, but also provides a quantitative assessment of the strategy's reliability, thereby enhancing the transparency and interpretability of the task partitioning process.

[0180] After obtaining the task segmentation strategy based on the aforementioned method, the task to be processed can be segmented according to the task segmentation strategy to obtain multiple subtasks. One optional implementation method of segmentation may include: determining the corresponding segmentation algorithm according to the partitioning mode identifier; and segmenting the task to be processed according to the segmentation algorithm and the task segmentation strategy to obtain multiple subtasks.

[0181] Specifically, the agent extracts a partitioning pattern identifier M from the task partitioning strategy. This identifier indicates the specific partitioning pattern type. Furthermore, the agent has a pre-defined mapping table between partitioning pattern identifiers and partitioning algorithms. This mapping table can be pre-configured or dynamically updated through machine learning.

[0182] Furthermore, the agent retrieves and determines the corresponding segmentation algorithm from the mapping table based on the segmentation mode identifier M, which serves as the execution logic for subsequent segmentation processing.

[0183] For example, if the partitioning pattern identifier M indicates a hybrid parallel mode, the corresponding partitioning algorithm is a multi-mode combined partitioning algorithm, such as hierarchical partitioning or recursive partitioning. If the partitioning pattern identifier M indicates a data parallel mode, the corresponding partitioning algorithm is a data sharding algorithm, such as dimensional partitioning, batch partitioning, or hash-based partitioning. If the partitioning pattern identifier M indicates a semantic pattern, the corresponding partitioning algorithm is a spectral clustering algorithm, etc.

[0184] After determining the splitting algorithm, the agent uses other parameters in the task splitting strategy as input parameters for the splitting algorithm and performs splitting processing on the task to be processed.

[0185] Specifically, the agent invokes a predetermined partitioning algorithm, using a parallelism suitability P as the criterion for whether to enable parallel partitioning. For example, parallel partitioning is only performed when P is higher than a preset threshold. Based on the determination that parallel partitioning is enabled, a recommended parallelism K is used as the target number of subtasks. The partitioning algorithm then divides the task graph G or input data according to the partitioning strategy indicated by the partitioning mode identifier M, generating K subtasks, each corresponding to an independent execution unit. After partitioning, the agent outputs a list of subtasks, each containing information such as its corresponding computational logic, input data fragments, dependencies, and execution priority.

[0186] In one exemplary implementation, if the partitioning pattern identifier M indicates a semantic clustering pattern, the agent uses an improved spectral clustering algorithm for partitioning, that is, dividing the intermediate representation data G into N subgraphs {G1, G2, …, G}. n The partitioning objective is to minimize the weights of the dependency edges between subgraphs. Specifically, we define a subgraph G. i The cost function J(G) i )for:

[0187]

[0188] Where w(u,v) is the weight of edge (u,v), which represents the strength of the dependency or the amount of data interaction between subtask u and subtask v.

[0189] The agent aims to minimize the sum of costs of all subgraphs. It uses an improved spectral clustering algorithm to partition the task graph G, so that semantically similar and closely dependent subtasks are grouped into the same subgraph, while the weight of the dependency edges between subgraphs is minimized, thereby reducing the data interaction overhead across subgraphs and improving the efficiency of parallel execution.

[0190] After obtaining multiple subtasks, the agent can also verify the segmentation results, such as checking whether the dependencies between subtasks are complete, whether the data shards are consistent, and whether the number of subtasks matches the recommended parallelism. If the verification fails, the agent can fine-tune the segmentation parameters based on confidence or a preset fault tolerance mechanism and re-execute the segmentation process until a set of subtasks that meets the requirements is obtained.

[0191] In the above implementation, the agent automatically determines and calls the corresponding segmentation algorithm based on the partitioning mode identifier in the task segmentation strategy, and accurately segments the task to be processed by combining parameters such as recommended parallelism, thereby transforming abstract strategy information into executable sub-tasks and improving the overall execution efficiency and reliability of the task.

[0192] In the implementation of the above embodiments, after obtaining the task scenario and intermediate representation data of the task to be processed, the present application embodiment also simultaneously constructs a directed acyclic graph corresponding to the task to be processed based on the intermediate representation data.

[0193] Specifically, after acquiring the task scenario and intermediate representation data (such as abstract syntax trees, data flow graphs, control flow graphs, or intermediate code representations) of the task to be processed, the agent extracts multi-dimensional feature data and contextual information, and simultaneously constructs a directed acyclic graph (DAG) corresponding to the task to be processed based on the intermediate representation data. The DAG is used to represent the dependencies between subtasks and the task execution tracing chain.

[0194] Specifically, when constructing the directed acyclic graph (DAG), the agent first parses the intermediate representation data to identify the basic computational units or operation steps contained in the task to be processed. Each basic computational unit corresponds to a vertex (node) in the DAG. At the same time, the agent also analyzes the data dependencies, control dependencies, or resource dependencies between the computational units and represents these dependencies as directed edges in the DAG.

[0195] For example, if the execution of computation unit B depends on the output of computation unit A, then a directed edge from node A to node B is added to the directed acyclic graph.

[0196] The constructed directed acyclic graph (DAG) serves two main purposes: First, the directed edges in the DAG clearly depict the dependencies between subtasks. When splitting tasks, the agent can distinguish which subtasks have no dependencies and can be executed in parallel, and which subtasks have dependency chains and must be executed sequentially, thus guiding the formulation of the splitting strategy. Second, each path from the starting node to the ending node in the DAG constitutes a complete task execution tracking chain. During execution, the agent can monitor the execution progress of each subtask in real time, quickly locate execution anomalies, and effectively trace the source of execution results based on this tracking chain.

[0197] Based on the constructed directed acyclic graph, the agent can dispatch and execute subtasks according to the dependencies in the directed acyclic graph and the execution status of each subtask indicated in the tracking chain, thereby achieving efficient dispatch and execution of subtasks.

[0198] The above implementation method, by synchronously constructing a directed acyclic graph corresponding to the tasks to be processed, can clearly depict the dependencies between each subtask and form a complete task execution tracing chain. This allows for accurate differentiation between subtasks that can be executed in parallel and those that must be executed serially during the task segmentation stage. During the task execution stage, it enables automated dispatching and efficient scheduling of subtasks based on dependencies and real-time status, effectively improving the efficiency of parallel task execution.

[0199] Based on the above implementation method, an optional implementation method for dispatching and executing subtasks may include: selecting ready subtasks from the directed acyclic graph using a preset scheduling algorithm, according to the directed acyclic graph, until all subtasks are selected and executed; wherein, ready subtasks are subtasks whose prerequisite dependencies have been satisfied; dispatching the selected ready subtasks in groups to the execution environment of the current agent, and injecting context information into the execution environment of each subtask when dispatching each subtask; after each subtask is executed, obtaining the subtask data corresponding to each subtask from the execution environment; and aggregating the subtask data according to the dependency relationship to obtain the task result data corresponding to the task to be processed.

[0200] Specifically, based on the constructed directed acyclic graph (DAG), the agent uses a pre-defined scheduling algorithm, such as topology sorting, critical path scheduling, or priority-based scheduling, to iteratively select subtasks currently in the ready state from the DAG until all subtasks have been selected and executed. Here, a ready subtask refers to a subtask whose all prerequisites have been satisfied; that is, all predecessor nodes corresponding to the subtask have been executed, and all dependency conditions have been met.

[0201] In this embodiment, the agent maintains a ready queue, which is initially filled with subtasks that have no prerequisites. The agent then performs the following operations in a loop: it retrieves one or more ready subtasks from the ready queue and dispatches them for execution. After a subtask completes execution, it updates the in-degree information of its successor nodes in the directed acyclic graph. If the in-degree of a successor node becomes zero, it adds it to the ready queue. This process is repeated until all subtasks have been selected and executed.

[0202] Based on this, the agent groups the selected ready subtasks, grouping subtasks from the same batch or with similar resource requirements together, and dispatches them to the agent's execution environment. It should be understood that the execution environment can be an internal thread pool, process pool, container instance, or remote computing node, etc.

[0203] Optionally, when dispatching each subtask, the agent injects the previously extracted context information into the execution environment of each subtask. In this way, each subtask can directly access the required context information during execution without repeatedly acquiring or recalculating it, thereby reducing execution overhead and improving execution efficiency.

[0204] After each subtask is executed independently in its respective execution environment, it generates corresponding subtask data, including calculation results, intermediate data, execution logs, and status flags. The agent collects and retrieves the subtask data corresponding to each subtask from the execution environment and associates it with the corresponding nodes in the directed acyclic graph for storage, so as to facilitate subsequent data aggregation and result summarization.

[0205] Based on the dependencies recorded in the directed acyclic graph, the agent aggregates the data of each subtask layer by layer according to the topological order or the reverse order of the dependency chain. Specifically, for subtasks with dependencies, the agent merges, splices, reduces, or fuses the data of the subsequent subtask with the data of the preceding subtask, and finally obtains the complete task result data corresponding to the task to be processed.

[0206] The above implementation method, through a collaborative mechanism based on directed acyclic graphs and scheduling algorithms, achieves automated selection, grouping and dispatching, context injection, data collection and result aggregation of subtasks, thereby maximizing parallel execution efficiency and resource utilization while ensuring the correctness of dependencies.

[0207] After completing the task to be processed and obtaining its corresponding task result data based on the aforementioned method, this embodiment further includes: storing the task processing data of the task to be processed into a historical task database; wherein, the task processing data is used as historical task data to participate in the scoring of the task segmentation strategy in subsequent task processing.

[0208] Specifically, after completing the execution of the task to be processed and obtaining the task result data, the intelligent agent extracts the task processing data generated during the entire processing process. The task processing data includes, but is not limited to: task scenario description, intermediate representation data, directed acyclic graph structure, subtask partitioning scheme, execution time of each subtask, resource consumption, execution order of dependencies, context information, task result data, and exception records during the execution process.

[0209] The extracted task processing data is stored in a historical task database. This data is used as historical task data in the scoring of the task segmentation strategy during subsequent task processing. In this embodiment, the historical task database can be a local database, a distributed database, or a cloud storage system, used to persistently store all completed task processing data. Each piece of task processing data is associated with a unique task identifier and includes metadata information such as a timestamp, task type, and execution environment for subsequent retrieval and reuse.

[0210] Based on this, when the agent processes a new task, it can retrieve historical task data similar to the current task scenario from the historical task database, extracting indicators such as segmentation strategy, execution efficiency, and resource consumption. These indicators can then be used as a reference to score and rank the candidate segmentation strategies for the current task. For example, if historical task data shows that a certain segmentation strategy has achieved high parallel efficiency in similar scenarios, the agent will assign a higher weight or priority to that strategy when scoring.

[0211] Through the above implementation method, the task processing data generated during each task processing can be persistently stored and fed back as historical task data to the subsequent task segmentation strategy scoring stage, realizing the accumulation and reuse of task processing experience, thereby continuously optimizing the overall efficiency of task segmentation and execution.

[0212] Next, using a specific marketing case within a marketing planning scenario as an example, the implementation process of the technical solution of this application will be further explained. Similarly, the following description is merely an exemplary implementation of the technical solution of this application and does not constitute any limitation on the technical solution of this application.

[0213] Figure 3 A flowchart illustrating another task processing method provided in an embodiment of this application. See also... Figure 3 This application uses the automated configuration system of the "October Cross-border Travel" marketing campaign on a cross-border marketing platform as an example to illustrate the above technical solution in detail. This campaign requires the generation of a complete JSON configuration file to drive multi-dimensional configuration input in the backend. The configuration content includes five tightly coupled modules: core campaign rules (campaign time window, budget, organizer, etc.), campaign scenario rules (by region, device, user group, threshold, campaign gameplay, etc.), user customization rules (allocating different discount amounts to users with different tags, such as "high-value users," "low-activity users," and "new registrations" enjoying different tiers of discounts), incentive strategy configuration (setting customized reminders and generating different incentive strategies based on different user tags, such as "if a user has the 'new registration' tag, issue a 50 RMB no-threshold coupon"), and resource and delivery configuration (specifying coupon type, inventory, distribution channel, validity period, etc.). The entire configuration involves 118 necessary configuration items, of which 46 have referential relationships, mainly related to user configurations. For example, the incentive gameplay in the "user customization rules" depends on the user tags involved in the "campaign scenario rules."

[0214] This results in an 80% chance that the output will lack an incentive strategy, and the content output of the targeted feature enhancement still has a certain configuration item deviation. Ultimately, it requires two senior operations staff to manually check and supplement the additional configuration, which takes an average of 15 minutes per instance.

[0215] The specific implementation process of this application embodiment is as follows: The marketing configuration table is distributed by the API gateway to an available task analysis center. The task parser does not rely on manual intervention but identifies the intent of the input content as a marketing scenario. Under the current marketing scenario, it automatically converts the configuration requirements into a directed graph structure G=(V,E,A) with attributes. Among them, 118 configuration items are mapped to the vertex set V in the graph, 46 reference relationships are mapped to the directed edge set E, and metadata A stores the original text of each configuration item.

[0216] The feature analyzer determines which small model to call based on the scenario pattern and is optimized for the marketing scenario. Based on graph G, the system calculates multi-dimensional task feature vector T: the structural complexity is obtained by calculating the average degree and clustering coefficient of the graph, the semantic relevance is obtained by the vertex embedding similarity matrix, and the cohesion strength is obtained by the cross-vertex reference chain.

[0217] While calculating the feature vector T, the feature analyzer performs semantic optimization on the marketing features. The system uses a graph centrality algorithm to calculate the influence score of each vertex on the global semantics, automatically extracting the core features with the highest scores, such as the event name, simplified description of the event algorithm, and target user tags. This content is formatted and output by the model to form a context pack (i.e., the feature data packet), which serves as a memory anchor for subsequent tasks. Data examples are as follows: | October Cross-border Travel | Cross-border Discount Coupons | RMB | 50-10 | Apple Pay | ...

[0218] The intelligent decomposer inputs the feature vector T into the ensemble learning model. The model retrieves historical experience data based on the feature data, infers and generates multiple task execution plans, and outputs a decision tuple Decision=(P,K,M,S). During this process, the system returns a recommended set of task patterns for decision-making reference, for example:

[0219] Spring Festival travel discount coupon campaign: Main rule - Task A; User - Task B, Incentive - Notification - Task B1; Incentive - Coupon Issuance - Task B2... Execution score: 81; Main issues: xxx;

[0220] Overseas travel planning: Main rule - Task A; User - Task B, Incentive - Registration - Task B1; ... Execution score: 81; Main issues: xxx;

[0221] The system generates planning tasks based on the top N results and estimates scores by combining factors such as historical task fit, current scheduling resources, and the completeness of information in each marketing segment. The model ultimately outputs the optimal decision: parallel suitability score P, recommended descent degree K (e.g., dividing into multiple task groups), partitioning pattern identifier M (e.g., indicating partitioning by logical modules), and confidence score S.

[0222] After selecting the optimal planning scheme, the segmentation strategy generator executes the segmentation algorithm based on the partitioning pattern M in the decision tuple. If M indicates semantic clustering, an improved spectral clustering algorithm is adopted to dynamically segment the current marketing information into various sub-tasks with the goal of minimizing the weight cost function J(G_i) of the dependent edges between subgraphs.

[0223] After checking the rationality of the subtasks, the dependency graph construction module analyzes the various dependencies between the subtasks, establishes task dependency relationships and task execution tracing chains, and constructs a directed acyclic graph (DAG). For example, the constructed DAG structure clearly shows that task group A consists of A, group B contains B, B1, and B2, and B1 and B2 must be executed after B is completed.

[0224] After receiving a task, the agent scheduling engine identifies various task relationships within the DAG. The engine employs a resource-aware list scheduling algorithm, cyclically selecting "ready" nodes (i.e., tasks whose prerequisites have been satisfied) from the DAG based on the directed acyclic graph structure, and then scheduling the agent cluster in groups.

[0225] When dispatching subtasks, the scheduling engine forcibly injects the previously generated ContextPack (containing data such as "|October cross-border travel|...|new registration tag|) into the execution environment of each subtask. This ensures that the agent handling the "incentive strategy configuration" is fully aware of the specific semantics of tags such as "new registration" during execution, thus accurately generating the configuration "if the user has the 'new registration' tag, issue a 50 yuan no-threshold coupon," fundamentally solving the problem of 80% missing incentive strategies in the original solution.

[0226] Each subtask is monitored in real time and returns a structured JSON fragment. Since the semantic premises of the downstream tasks have been clearly defined through context anchors, the consistency checker of the result aggregator did not find any logical conflicts when performing constraint satisfaction checks (constraint checks of the objective function F(x)).

[0227] Optionally, if a conflict is found, a conflict resolution process must be executed, and a consistency check must be performed again until there are no logical conflicts.

[0228] Therefore, the intelligent fusion module does not need to initiate a complex arbitration channel; it directly executes a deep merging algorithm to concatenate and fill in missing fields in the JSON content, generating a complete set of 118 final configuration items. Finally, the system scores the execution result and uploads the complete execution chain data of this task to the data management layer for subsequent online incremental updates of the machine learning model.

[0229] Through the above implementation methods, the embodiments of this application can realize the automated generation of marketing activity configurations, effectively solve the problem of missing and biased configuration items caused by the lack of cross-module dependency awareness, significantly reduce the time cost of manual verification and completion, and improve the efficiency and accuracy of configuration generation.

[0230] The performance of this solution in a continuous 30-day A / B test (generating 20-50 similar configurations per day) is shown in the table below:

[0231] Table 1

[0232]

[0233] In addition, the system successfully identified and handled three circular dependencies caused by operational errors during the "Building DAG" phase, and detected errors in advance through dependency graph detection, thus avoiding invalid execution.

[0234] Figure 4 A schematic diagram of the task processing device provided in this application is shown below. Figure 4 As shown, the task processing device 40 provided in this embodiment includes:

[0235] The task parsing module 401 is used to parse the task to be processed in response to receiving the task to be processed, so as to obtain the multi-dimensional feature data and context information of the task to be processed.

[0236] The task segmentation module 402 is used to determine the task segmentation strategy based on multidimensional feature data, and to segment the task to be processed into multiple sub-tasks according to the task segmentation strategy.

[0237] The task execution module 403 is used to determine the dependencies between multiple subtasks, and execute multiple subtasks in the order indicated by the dependencies according to the context information, so as to generate task result data corresponding to the task to be processed.

[0238] In one possible implementation, the task parsing module 401 is specifically used for:

[0239] The task to be processed is parsed to obtain the task scenario and intermediate representation data of the task to be processed.

[0240] Based on the task scenario and intermediate representation data, multidimensional feature data and context information of the task to be processed are generated.

[0241] In one possible implementation, the task parsing module 401 is specifically used for:

[0242] Determine the appropriate feature extraction algorithm based on the task scenario;

[0243] Based on the feature extraction algorithm and combined with the intermediate representation data, feature extraction is performed to obtain multidimensional feature data of the task to be processed.

[0244] In one possible implementation, the intermediate representation data is directed graph data; the directed graph data includes task node data, associated edge data, and node attribute data;

[0245] Task parsing module 401 is specifically used for:

[0246] Based on the pre-acquired context extraction algorithm and combined with node attribute data, context extraction is performed to obtain the context information of the task to be processed.

[0247] In one possible implementation, the task splitting module 402 is specifically used for:

[0248] Retrieve historical tasks that match the pending task;

[0249] Based on the task processing data of historical tasks, each initial segmentation strategy is scored to obtain a strategy score for each initial segmentation strategy.

[0250] Based on the preset strategy reasoning algorithm and combined with multi-dimensional feature data, strategy reasoning is performed to obtain N initial segmentation strategies; where N is a positive integer greater than or equal to 2.

[0251] Determine the strategy score for each initial segmentation strategy, and select the initial segmentation strategy with the highest strategy score as the task segmentation strategy.

[0252] In one possible implementation, the task splitting module 402 is specifically used for:

[0253] In one possible implementation, the task partitioning strategy includes: parallelism suitability, recommendation parallelism, partitioning pattern identifier, and confidence level; among which...

[0254] Parallelism suitability is used to evaluate whether a task is suitable for parallel processing.

[0255] The recommended parallelism is used to determine the optimal number of subtasks;

[0256] The partitioning pattern identifier is used to indicate the specific partitioning strategy;

[0257] Confidence level is used to indicate the reliability of prediction results.

[0258] In one possible implementation, the task splitting module 402 is specifically used for:

[0259] The corresponding segmentation algorithm is determined based on the partitioning pattern identifier;

[0260] Based on the segmentation algorithm and combined with the task segmentation strategy, the task to be processed is segmented into multiple subtasks.

[0261] In one possible implementation, the device is also used for:

[0262] After obtaining the task scenario and intermediate representation data of the task to be processed, a directed acyclic graph corresponding to the task to be processed is constructed based on the intermediate representation data; the directed acyclic graph is used to represent the dependency relationship between subtasks and the task execution tracing chain.

[0263] In one possible implementation, task execution module 403 is specifically used for:

[0264] Based on the directed acyclic graph, a preset scheduling algorithm is used to iteratively select ready subtasks from the directed acyclic graph until all subtasks have been selected and executed; among them, ready subtasks are those whose prerequisites have been satisfied.

[0265] The selected ready subtasks are grouped and dispatched to the execution environment of the current agent, and context information is injected into the execution environment of each subtask when dispatching each subtask.

[0266] After each subtask is completed, the subtask data corresponding to each subtask is obtained from the execution environment;

[0267] Based on the dependencies, the data of each subtask is aggregated to obtain the task result data corresponding to the task to be processed.

[0268] In one possible implementation, the device is also used for:

[0269] After generating the task result data corresponding to the task to be processed, the task processing data of the task to be processed is stored in the historical task database; the task processing data is used as historical task data to participate in the scoring of the task splitting strategy in the subsequent task processing process.

[0270] The task processing device provided in this embodiment can execute the method provided in the above method embodiment. Its implementation principle and technical effect are similar, and will not be described in detail here.

[0271] Figure 5 A schematic diagram of the structure of the electronic device provided in this application. Figure 5 As shown, the electronic device 50 provided in this embodiment includes at least one processor 501 and a memory 502. Optionally, the device 50 further includes a communication component 503. The processor 501, memory 502, and communication component 503 are connected via a bus 504.

[0272] In a specific implementation, at least one processor 501 executes computer execution instructions stored in memory 502, causing at least one processor 501 to perform the above-described method.

[0273] The specific implementation process of processor 501 can be found in the above method embodiments, and its implementation principle and technical effect are similar. It will not be repeated here.

[0274] In the above embodiments, it should be understood that the processor can be a Central Processing Unit (CPU), or other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), etc. The general-purpose processor can be a microprocessor or any conventional processor. The steps of the method disclosed in this invention can be directly implemented by a hardware processor, or implemented by a combination of hardware and software modules within the processor.

[0275] The memory may include random access memory (RAM) and may also include non-volatile memory (NVM), such as at least one disk storage device.

[0276] The bus can be an Industry Standard Architecture (ISA) bus, a Peripheral Component Interconnect (PCI) bus, or an Extended Industry Standard Architecture (EISA) bus, etc. Buses can be categorized as address buses, data buses, control buses, etc. For ease of illustration, the buses shown in the accompanying drawings are not limited to a single bus or a single type of bus.

[0277] This application also provides a computer program product, including a computer program that, when executed by a processor, implements the above-described method.

[0278] This application also provides a computer-readable storage medium storing computer-executable instructions, which, when executed by a processor, implement the above-described method.

[0279] The aforementioned readable 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 storage, flash memory, magnetic disk, or optical disk. The readable storage medium can be any available medium accessible to a general-purpose or special-purpose computer.

[0280] An exemplary readable storage medium is coupled to a processor, enabling the processor to read information from and write information to the readable storage medium. Of course, the readable storage medium can also be a component of the processor. The processor and the readable storage medium can reside in an Application Specific Integrated Circuit (ASIC). Alternatively, the processor and the readable storage medium can exist as discrete components in the device.

[0281] The division of units is merely a logical functional division; in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be indirect coupling or communication connection through some interfaces, devices, or units, and may be electrical, mechanical, or other forms.

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

[0283] In addition, the functional units in the various embodiments of the present invention can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit.

[0284] If a function is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this invention, or the part that contributes to the prior art, or a part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods of the various embodiments of this invention. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0285] Those skilled in the art will understand that all or part of the steps of the above-described method embodiments can be implemented by hardware related to program instructions. The aforementioned program can be stored in a computer-readable storage medium. When executed, the program performs the steps of the above-described method embodiments; and the aforementioned storage medium includes various media capable of storing program code, such as ROM, RAM, magnetic disks, or optical disks.

[0286] Finally, it should be noted that other embodiments of the invention will readily occur to those skilled in the art upon consideration of the specification and practice of the invention disclosed herein. This invention is intended to cover any variations, uses, or adaptations of the invention that follow the general principles of the invention and include common knowledge or customary techniques in the art not disclosed herein, and is not limited to the precise structures described above and shown in the accompanying drawings, and various modifications and changes can be made without departing from its scope. The scope of the invention is limited only by the appended claims.

Claims

1. A task processing method, characterized in that, Applied to intelligent agents, including: In response to receiving a task to be processed, the task to be processed is parsed to obtain multidimensional feature data and context information of the task to be processed; Based on the multidimensional feature data, a task segmentation strategy is determined, and the task to be processed is segmented into multiple sub-tasks according to the task segmentation strategy. Determine the dependencies between the multiple subtasks, and execute the multiple subtasks in the execution order indicated by the dependencies according to the context information, so as to generate task result data corresponding to the task to be processed.

2. The method according to claim 1, characterized in that, The task to be processed is parsed to obtain multidimensional feature data and contextual information of the task to be processed, including: The task to be processed is parsed to obtain the task scenario and intermediate representation data of the task to be processed. Based on the task scenario and the intermediate representation data, multidimensional feature data and context information of the task to be processed are generated.

3. The method according to claim 2, characterized in that, Based on the intermediate representation data and the task scenario, multidimensional feature data of the task to be processed is generated, including: Based on the task scenario, determine the corresponding feature extraction algorithm; Based on the feature extraction algorithm and the intermediate representation data, feature extraction is performed to obtain the multidimensional feature data of the task to be processed.

4. The method according to claim 2, characterized in that, The intermediate representation data is directed graph data; the directed graph data includes task node data, associated edge data, and node attribute data; Based on the intermediate representation data and the task scenario, context information for the task to be processed is generated, including: Based on the pre-acquired context extraction algorithm and combined with the node attribute data, context extraction is performed to obtain the context information of the task to be processed.

5. The method according to claim 1, characterized in that, Based on the multidimensional feature data, a task segmentation strategy is determined, including: Based on the preset strategy reasoning algorithm and combined with the multidimensional feature data, strategy reasoning is performed to obtain N initial segmentation strategies; where N is a positive integer greater than or equal to 2. Determine the strategy score of each initial segmentation strategy, and determine the initial segmentation strategy with the highest strategy score as the task segmentation strategy.

6. The method according to claim 5, characterized in that, Determine the strategy score for each of the initial segmentation strategies, including: Obtain historical tasks that match the task to be processed; Based on the task processing data of the historical tasks, each of the initial segmentation strategies is scored to obtain a strategy score for each initial segmentation strategy.

7. The method according to claim 5, characterized in that, The task segmentation strategy includes: parallelism suitability, recommended parallelism, partitioning pattern identifier, and confidence level; wherein... The parallelism suitability is used to assess whether a task is suitable for parallel processing. The recommended parallelism is used to determine the optimal number of subtasks; The partitioning mode identifier is used to indicate the specific partitioning strategy; The confidence level is used to indicate the reliability of the prediction result.

8. The method according to claim 7, characterized in that, The task to be processed is divided into multiple sub-tasks according to the task segmentation strategy, including: Based on the partitioning pattern identifier, the corresponding segmentation algorithm is determined; Based on the segmentation algorithm and the task segmentation strategy, the task to be processed is segmented to obtain multiple sub-tasks.

9. The method according to claim 2, characterized in that, After obtaining the task scenario and intermediate representation data of the task to be processed, the method further includes: Based on the intermediate representation data, a directed acyclic graph corresponding to the task to be processed is constructed; wherein, the directed acyclic graph is used to represent the dependency relationship between each of the subtasks and the task execution tracing chain.

10. The method according to claim 9, characterized in that, The plurality of subtasks are executed in the execution order indicated by the dependency relationship to generate task result data corresponding to the task to be processed, including: Based on the directed acyclic graph, a preset scheduling algorithm is used to cyclically select ready subtasks from the directed acyclic graph until all subtasks are selected and executed; wherein, the ready subtasks are subtasks whose prerequisites have been satisfied. The selected subtasks in the ready state are grouped and dispatched to the execution environment of the current agent, and the context information is injected into the execution environment of each subtask when dispatching each subtask. After each of the subtasks is completed, the subtask data corresponding to each subtask is obtained from the execution environment; Based on the aforementioned dependencies, the data of each subtask are aggregated to obtain the task result data corresponding to the task to be processed.

11. The method according to claim 1, characterized in that, After generating the task result data corresponding to the task to be processed, the method further includes: The task processing data of the task to be processed is stored in the historical task database; wherein, the task processing data is used as historical task data to participate in the scoring of the task segmentation strategy in the subsequent task processing process.

12. A task processing device, characterized in that, include: The task parsing module is used to parse the task to be processed in response to receiving the task to be processed, so as to obtain the multidimensional feature data and context information of the task to be processed; The task segmentation module is used to determine a task segmentation strategy based on the multidimensional feature data, and to segment the task to be processed into multiple sub-tasks according to the task segmentation strategy. The task execution module is used to determine the dependencies between the multiple subtasks, and execute the multiple subtasks in the execution order indicated by the dependencies according to the context information, so as to generate task result data corresponding to the task to be processed.

13. An electronic device, characterized in that, include: Memory, processor; The memory stores computer-executed instructions; The processor executes computer execution instructions stored in the memory, causing the processor to perform the method as described in any one of claims 1-11.

14. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer-executable instructions, which, when executed by a processor, are used to implement the method as described in any one of claims 1-11.

15. A computer program product, characterized in that, Includes a computer program that, when executed by a processor, implements the method described in any one of claims 1-11.

Images