Node task generation method, electronic equipment, readable storage medium and product

Abstract

The invention discloses a nodal task generation method, electronic equipment, a readable storage medium and a product, and relates to the technical field of artificial intelligence, the method comprises the steps that a task knowledge graph of a service scene is constructed, and the task knowledge graph comprises task nodes and semantic relation information between the task nodes; a dependency weight matrix is extracted from the semantic relation information between the task nodes through a preset neural network model, and the dependency weight matrix is used for representing the dependency relation between the task nodes; and sorting the task nodes through the dependency weight matrix to obtain a target task flow of the business scene. According to the task flow generation method and device, automatic generation of the task flow is achieved, the problems of subjectivity and low efficiency existing in a task flow construction mode are solved, and then actual service requirements are better met.

Description

Technical Field

[0001] This application relates to the field of artificial intelligence technology, and in particular to a node-based task generation method, electronic device, readable storage medium, and product. Background Technology

[0002] Currently, many business scenarios, such as government services and internal enterprise processes, require the construction of standardized task workflows. Traditional task workflows largely rely on manual processes; for example, personnel can manually create task workflows by dragging and dropping elements on a no-code business platform. However, because this relies on human understanding of the actual business scenario and the creation of the workflow, the efficiency of workflow construction is relatively slow. Furthermore, when business requirements or related policies change frequently, manual construction methods cannot respond to changes in a timely manner. Therefore, current traditional task workflow construction methods fail to meet actual business needs.

[0003] The above content is only used to help understand the technical solution of this application and does not represent an admission that the above content is prior art. Summary of the Invention

[0004] The main purpose of this application is to provide a node-based task generation method, electronic device, readable storage medium and product, which aims to solve the technical problem that the current traditional task flow construction method is difficult to meet the actual business needs.

[0005] To achieve the above objectives, this application proposes a node-based task generation method, which includes: Construct a task knowledge graph for business scenarios, wherein the task knowledge graph includes each task node and the semantic relationship information between task nodes; A dependency weight matrix is ​​extracted from the semantic relationship information between the task nodes using a preset neural network model, wherein the dependency weight matrix is ​​used to characterize the dependency relationship between the task nodes. The task nodes are sorted using the dependency weight matrix to obtain the target task flow for the business scenario.

[0006] Optionally, the node-based task generation method further includes: Entity relationships are extracted from the new information in the business scenario and / or the execution feedback of the target task process to obtain the updated graph content; The task knowledge graph is updated by updating the graph content to obtain a new task knowledge graph, and the cumulative update amount of the task knowledge graph is recorded. If the cumulative update amount of the task knowledge graph exceeds a preset cumulative threshold, the step of extracting the dependency weight matrix from the semantic relationship information between the task nodes using a preset neural network model is returned based on the new task knowledge graph; or, the preset neural network model is incrementally learned based on the new task knowledge graph to obtain a new preset neural network model, and the step of extracting the dependency weight matrix from the semantic relationship information between the task nodes using a preset neural network model is returned based on the new task knowledge graph and the new preset neural network model.

[0007] Optionally, the step of sorting each task node using the dependency weight matrix to obtain the target task flow of the business scenario includes: Based on the dependency weight matrix, each task node is sorted to generate a candidate task process set; From the candidate task flows in the task flow set, the candidate task flows without conflicts are selected as the target task flow.

[0008] Optionally, the dependency weight matrix includes the dependency weight between any two task nodes in each task node, and the step of sorting the task nodes based on the dependency weight matrix to generate a candidate task process set includes: The dependency weights in the dependency weight matrix that are less than a preset threshold are filtered out to obtain the target dependency weight matrix; Based on the dependency weights in the target dependency weight matrix, construct a sequence of directed task nodes composed of the task nodes. Candidate task flows are determined based on the sequence of each directed task node, and the candidate task flows are combined to form the candidate task flow set.

[0009] Optionally, the step of determining the candidate task flow based on the sequence of directed task nodes includes: Detect any of the directed task node sequences; If the detection result indicates that the directed task node sequence is a circular sequence, the position corresponding to the lowest dependency weight in the directed task node sequence is disconnected to form a directed acyclic task node sequence. The directed acyclic task node sequence is sorted using a topology algorithm to obtain candidate task flows.

[0010] Optionally, the step of selecting conflict-free candidate task flows from each candidate task flow in the task flow set as the target task flow includes: Conflict detection is performed between the candidate task processes in the candidate task process set by using preset task constraint rules. Based on the conflict detection results, conflict-free candidate task flows are selected as the target task flow.

[0011] Optionally, the step of extracting the dependency weight matrix from the semantic relationship information between the task nodes using a preset neural network model includes: The task knowledge graph, including the semantic relationship information, is input into the preset neural network model to obtain the dependency weight matrix of each task node. The preset neural network model is used to aggregate the neighbor node features of each task node in the task knowledge graph based on the semantic relationship information, and to identify the dependency weight matrix based on the neighbor node features of each task node.

[0012] In addition, to achieve the above objectives, this application also proposes an electronic device, the device comprising: a memory, a processor, and a computer program stored in the memory and executable on the processor, the computer program being configured to implement the steps of the node-based task generation method described above.

[0013] In addition, to achieve the above objectives, this application also proposes a storage readable storage medium, which is a computer readable storage medium, on which a computer program is stored, and when the computer program is executed by a processor, it implements the steps of the node-based task generation method described above.

[0014] In addition, to achieve the above objectives, this application also provides a computer program product, which includes a computer program that, when executed by a processor, implements the steps of the node-based task generation method described above.

[0015] One or more technical solutions proposed in this application have at least the following technical effects: In this embodiment, a task knowledge graph for a business scenario is constructed. The task knowledge graph includes task nodes and semantic relationship information between them. A dependency weight matrix is ​​extracted from the semantic relationship information between the task nodes using a preset neural network model. This dependency weight matrix represents the dependencies between the task nodes. The task nodes are then sorted using the dependency weight matrix to obtain the target task flow for the business scenario. Specifically, in this embodiment, a task knowledge graph is constructed to reflect the original semantic relationship information between task nodes in the business scenario. A preset neural network model then extracts the dependency weight matrix from the semantic relationship information included in the task knowledge graph, thereby quantifying the hidden dependencies between task nodes. The target task flow can then be constructed based on the dependency weight matrix and the task nodes. This achieves automated generation of the task flow, solving the problems of subjectivity and inefficiency in traditional task flow construction methods, and better meeting actual business needs. Attached Figure Description

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

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

[0018] Figure 1 This is a flowchart illustrating the first embodiment of the node-based task generation method in this application; Figure 2 This is a flowchart illustrating the second embodiment of the node-based task generation method in this application; Figure 3 This is a flowchart illustrating the third embodiment of the node-based task generation method in this application; Figure 4 This is a schematic diagram of the overall process of the node-based task generation method in this application; Figure 5 This is a schematic diagram of the device structure of the hardware operating environment involved in the node-based task generation method in this application embodiment.

[0019] The purpose, features, and advantages of this application will be further explained in conjunction with the embodiments and with reference to the accompanying drawings. Detailed Implementation

[0020] It should be understood that the specific embodiments described herein are merely illustrative of the technical solutions of this application and are not intended to limit this application.

[0021] To better understand the technical solution of this application, a detailed description will be provided below in conjunction with the accompanying drawings and specific implementation methods.

[0022] Currently, many business scenarios, such as government services and internal enterprise processes, require the construction of standardized task workflows. Traditional task workflows largely rely on manual processes; for example, personnel can manually create task workflows by dragging and dropping elements on a no-code business platform. However, because this relies on human understanding of the actual business scenario and the creation of the workflow, the efficiency of workflow construction is relatively slow. Furthermore, when business requirements or related policies change frequently, manual construction methods cannot respond to changes in a timely manner. Therefore, current traditional task workflow construction methods fail to meet actual business needs.

[0023] The main solution of this application embodiment is: to construct a task knowledge graph of a business scenario, wherein the task knowledge graph includes each task node and semantic relationship information between task nodes; to extract a dependency weight matrix from the semantic relationship information between each task node through a preset neural network model, wherein the dependency weight matrix is ​​used to represent the dependency relationship between each task node; and to sort each task node through the dependency weight matrix to obtain the target task flow of the business scenario.

[0024] In this application, a task knowledge graph is constructed to reflect the original relationships between task nodes in a business scenario. Then, a pre-defined neural network model is used to extract the dependency weight matrix between task nodes from the task knowledge graph, thereby quantifying the hidden dependencies between them. Based on the dependency weight matrix and each task node, the target task flow can be constructed. This achieves automated task flow generation, solving the problems of subjectivity and inefficiency in traditional task flow construction methods, and thus better meeting actual business needs.

[0025] It should be noted that the execution subject of this embodiment can be a computing service device with data processing, network communication and program running functions, such as a server, computer, mobile phone, etc., or an electronic device capable of realizing the above functions.

[0026] Based on the above description, this application provides a method for generating node-based tasks, referring to... Figure 1 This is a flowchart illustrating the first embodiment of the node-based task generation method of this application.

[0027] In this embodiment, the node-based task generation method includes steps S10 to S30: Step S10: Construct a task knowledge graph for the business scenario, wherein the task knowledge graph includes each task node and the semantic relationship information between task nodes. It should be noted that this embodiment primarily replaces manual task generation with automated task flow generation; therefore, the execution entity of the aforementioned node-based task generation method is typically a server. Furthermore, the specific type of the aforementioned business scenario is determined by actual needs; for example, the business scenario could be a government service scenario or a business service provided by an enterprise to both internal and external parties. For ease of description, the following content will default to using a government service scenario as an example.

[0028] For example, in this embodiment, a task knowledge graph corresponding to the business scenario can be constructed using the Neo4j graph database. This task knowledge graph can include task nodes (i.e., entities) and semantic relationship information (i.e., edges) between task nodes. The attributes of a task node can include node type, state, and update time, while the semantic relationship information can be dependencies or preconditions. It should be noted that, based on actual needs, the semantic relationship information can refer to the semantic relationship between two specific task nodes, or it can be a collection of semantic relationships between any two adjacent nodes.

[0029] Optionally, a schema (metadata framework, entity-edge-entity) can be created using Neo4j's Cypher language (i.e., the query language for graph databases) to build a task knowledge graph corresponding to the business scenario. For example, in a government service scenario, the types of task nodes can include policy clauses, approval departments, and material lists. An example combining task nodes with semantic relationship information could be that policy clauses affect approval departments, approval departments require material lists, the prerequisite for the material lists is the application process, and the application process applies to the applicant, etc. Furthermore, the dynamic attributes of task nodes can be marked with the `last_updated` attribute to indicate the update time, enabling dynamic incremental updates of the knowledge graph to adapt to dynamic changes in needs and policies.

[0030] Step S20: Extract the dependency weight matrix from the semantic relationship information between each task node using a preset neural network model. The dependency weight matrix is ​​used to represent the dependency relationship between each task node. For example, after the knowledge graph is constructed, it can be input into a preset neural network model. The preset neural network model extracts the dependency weight matrix of each task node from the semantic relationship information included in the task knowledge graph. The preset neural network model can be a graph neural network (GNN). In a feasible implementation, an initial graph neural network can be constructed using PyTorch Geometric, and then trained to obtain the aforementioned preset neural network model. It is understood that the aforementioned preset neural network model is mainly used to extract the dependency relationship between any two task nodes from the task knowledge graph. The strength of the dependency relationship can be represented by the dependency weight. For example, the larger the dependency weight between two task nodes, the stronger the dependency relationship between the two task nodes. Therefore, the dependency weight matrix can characterize the dependency relationship between each task node.

[0031] Step S30: Sort each task node by using a dependency weight matrix to obtain the target task flow of the business scenario.

[0032] For example, a dependency weight matrix can be used to clearly define the dependencies between task nodes, and the task nodes can be sorted according to the direction and magnitude of the dependencies to construct a directed acyclic graph (DAG). For instance, if task node A has a dependency weight of 0.9 on node B (strong dependency), and node B has a dependency weight of 0.8 on node C, then A→B→C may form a directed acyclic graph. It can be understood that the arrangement of the task nodes in the directed acyclic graph can form a task flow, and this task flow can also be used as the target task flow.

[0033] In this embodiment, a task knowledge graph for the business scenario is constructed. This graph includes task nodes and semantic relationship information between them. A dependency weight matrix is ​​extracted from the semantic relationship information using a pre-defined neural network model. This dependency weight matrix represents the dependencies between task nodes. The task nodes are then sorted using the dependency weight matrix to obtain the target task flow for the business scenario. Specifically, this embodiment constructs a task knowledge graph to reflect the original semantic relationship information between task nodes in the business scenario. A pre-defined neural network model then extracts the dependency weight matrix from the semantic relationship information in the task knowledge graph, quantifying the hidden dependencies between task nodes. The target task flow can then be constructed based on the dependency weight matrix and the task nodes. This achieves automated task flow generation, solving the subjectivity and inefficiency problems of traditional task flow construction methods, and better meeting actual business needs.

[0034] In one feasible implementation, the step of extracting the dependency weight matrix of each task node from the task knowledge graph using a preset neural network model includes step S21: Step S21: Input the task knowledge graph including semantic relationship information into the preset neural network model to obtain the dependency weight matrix of each task node. The preset neural network model is used to aggregate the neighboring node features of each task node in the task knowledge graph based on the semantic relationship information, and to identify the dependency weight matrix based on the neighboring node features of each task node.

[0035] For example, the task knowledge graph, which includes semantic relationship information between task nodes, can be input into a preset neural network model (e.g., the node feature matrix and adjacency matrix from the knowledge graph can be input into the model). The preset neural network model then outputs the dependency weight matrix for each task node. The node feature matrix describes the attribute set of each node in the graph. For example, in a feasible implementation, the node feature matrix can be a two-dimensional matrix of [number of nodes × feature dimension], with each node corresponding to one row and each feature corresponding to one column. The adjacency matrix can be a square matrix of [number of nodes × number of nodes] describing the specific connection relationships between nodes, and can be constructed using the semantic relationship information included in the task knowledge graph.

[0036] Optionally, in the preset neural network model, a message passing mechanism can be used to aggregate the neighboring node features of each task node based on the semantic relationship information included in the task knowledge graph. Then, the node embeddings (i.e., the aggregated neighboring node features) are learned through the GCNConv or GraphSAGE layer in the preset neural network model, and the dependency weight matrix of the task nodes is output. The higher the weight value between two task nodes in the matrix, the stronger the dependency relationship between the two nodes. In a feasible implementation, the dependency weights of the two task nodes can be obtained by calculating the similarity between the neighboring node features of the two task nodes, and used to construct the dependency weight matrix.

[0037] Reference Figure 2 This is a flowchart illustrating a second embodiment of the node-based task generation method proposed in this application, based on the first embodiment of the method. Contents identical or similar to those in the above embodiments can be referred to the above description and will not be repeated hereafter. The node-based task generation method further includes steps S1 to S3: Step S1: Extract entity relationships from new information in the business scenario and / or execution feedback of the target task process to obtain the updated graph content; Step S2: Update the task knowledge graph with the updated graph content to obtain a new task knowledge graph, and record the cumulative update amount of the task knowledge graph. Step S3: If the cumulative update amount of the task knowledge graph is greater than the preset cumulative threshold, return to the step of extracting the dependency weight matrix from the semantic relationship information between each task node through the preset neural network model based on the new task knowledge graph; or, perform incremental learning on the preset neural network model based on the new task knowledge graph to obtain a new preset neural network model, and return to the step of extracting the dependency weight matrix from the semantic relationship information between each task node through the preset neural network model based on the new task knowledge graph and the new preset neural network model.

[0038] It should be noted that in practical applications, the content in the task knowledge graph may need to change dynamically according to actual needs.

[0039] For example, business scenarios may involve new information. In the context of government services, relevant service policies may change, and the new information could be the revised or newly added policies. During the execution of the target task process, the personnel performing the task can also provide corresponding feedback, i.e., execution feedback. For example, execution feedback could include comments such as "The process is unreasonable," and "Why is it unreasonable?"

[0040] For example, entity relationships can be extracted from newly added information and / or execution feedback to obtain the updated graph content. Optionally, newly added information can be extracted using an ALBERT-BiLSTM-CRF model. Taking newly added information as an example, if the newly added information is new policy text, an ALBERT-BiLSTM-CRF model can be used to encode the new policy text to generate a context vector, while constraining the legality of entity labels, thereby extracting entity relationships from the new policy text to obtain the updated graph content. Based on the updated graph content, the task knowledge graph is updated to obtain a new task knowledge graph. Optionally, the graph can be incrementally updated using the APOC plugin (Awesome Procedures On Cypher, a third-party extension library for the Neo4j graph database) to obtain a new task knowledge graph. Simultaneously, the cumulative update amount of the task knowledge graph is recorded. This cumulative update amount can be obtained by recording the graph update content at each update and quantifying and accumulating the update content. The cumulative update amount of the task knowledge graph serves as a parameter for determining whether subsequent steps are triggered.

[0041] For example, the accumulated amount of the task knowledge graph can be compared with a preset accumulated threshold. If the accumulated amount of the task knowledge graph is greater than the preset accumulated threshold, the step of extracting the dependency weight matrix of each task node from the task knowledge graph using a preset neural network model can be triggered based on the new task knowledge graph, and the accumulated amount of the task knowledge graph can be reset to zero simultaneously. Alternatively, the preset neural network model can be incrementally learned based on the new task knowledge graph to obtain a new preset neural network model. For example, in a feasible implementation, some model parameters in the preset neural network model can be solidified or isolated, and then the preset neural network model with solidified or isolated parameters can be trained using the new task knowledge graph to obtain a new preset neural network model. Then, based on the new task knowledge graph and the new preset neural network model, the step of extracting the dependency weight matrix of each task node from the task knowledge graph using the preset neural network model can be triggered. Optionally, when the added information is the applicable version or applicable time period of a node, the regeneration of the target task process can also be directly triggered, that is, the step of extracting the dependency weight matrix from the semantic relationship information between each task node using the preset neural network model can be triggered based on the new task knowledge graph.

[0042] It is understood that in this embodiment, the knowledge graph can be automatically updated based on new information in the business scenario and / or the execution feedback of the target task flow. Simultaneously, the cumulative update volume of the knowledge graph is recorded. When the cumulative update volume reaches a certain level, a preset neural network model is triggered to re-extract the dependency weight matrix, or the preset neural network model is triggered to perform incremental learning before re-extracting the dependency weights, and finally, the target task flow is regenerated. This ensures that the target flow matches the dynamic scenario requirements, meeting actual business needs.

[0043] Reference Figure 3 This is a flowchart illustrating the third embodiment of the node-based task generation method proposed in this application, based on the first and second embodiments. Content identical or similar to the above embodiments in this embodiment can be referred to the above description and will not be repeated hereafter. The steps for generating the target task process by relying on the weight matrix and each task node include steps S31 to S32: Step S31: Sort each task node based on the dependency weight matrix to generate a candidate task process set; Step S32: Select the non-conflicting candidate task flow from each candidate task flow in the task flow set as the target task flow.

[0044] For example, task nodes with dependencies can be connected and sorted according to the direction of their dependencies to form a sequence of task nodes, resulting in candidate task flows. These candidate task flows are then used to form a candidate task flow set. It is understood that the resulting candidate task flow set will typically include multiple candidate task flows. Therefore, it is necessary to filter the target task flow from the task flow set, for example, selecting conflict-free task flows as the target task flow.

[0045] In one feasible implementation, the dependency weight matrix includes the dependency weight between any two task nodes in each task node. The step of sorting each task node based on the dependency weight matrix and generating a candidate task process set includes steps S311 to S313: Step S311: Filter out dependency weights in the dependency weight matrix that are less than a preset threshold to obtain the target dependency weight matrix; Step S312: Based on the dependency weights in the target dependency weight matrix, construct a sequence of directed task nodes composed of each task node; Step S313: Determine candidate task processes based on each directed task node sequence, and combine each candidate task process into a candidate task process set.

[0046] For example, to ensure the quality of candidate task flows in the candidate task flow set, the dependency weights in the dependency weight matrix can be filtered. Specifically, dependency weights smaller than a preset threshold can be removed to obtain the target dependency weight matrix. For instance, dependency weights smaller than the preset threshold θ (θ=0.7) can be removed. It should be noted that removing a dependency weight also means discarding the dependency relationship between the two task nodes corresponding to that weight. In this way, some weakly dependent task node pairs can be ignored, avoiding redundancy in the generated candidate task flows and ensuring their quality. Furthermore, based on the dependency weights in the target dependency weight matrix, directed task node sequences composed of each task node can be constructed. For example, task nodes with dependencies can be connected to form a directed task node sequence, where the sequence direction of the directed task node sequence also represents the dependency direction between task nodes. Optionally, a directed task node sequence corresponds to a candidate task flow, and the candidate task flows can form a candidate task flow set.

[0047] In a feasible implementation, the step of determining the candidate task flow based on each directed task node sequence includes steps S301 to S303: Step S301: Detect any directed task node sequence; Step S302: If the detection result shows that the directed task node sequence is a circular sequence, disconnect the position corresponding to the lowest dependency weight in the directed task node sequence to form a directed acyclic task node sequence. Step S303: Sort the sequence of directed acyclic task nodes based on the topology algorithm to obtain the candidate task flow.

[0048] It should be noted that since the processing procedure for each directed task node is similar, this embodiment will use one directed task node sequence as an example for explanation; other directed task node sequences can be processed in the same manner.

[0049] For example, for any given sequence of directed task nodes, a pre-defined detection algorithm (such as depth-first search) can be used to detect it. This detection algorithm primarily ensures that the sequence is a linear execution sequence while strictly adhering to all dependencies. Specifically, detecting a directed task node sequence involves determining whether it is a cyclic sequence. For instance, during traversal, the state of task nodes is marked (unvisited, being visited, completed). If a node with a "being visited" state is encountered during traversal, it indicates the presence of a back edge, meaning a cycle has been detected. The detection result can be either that the directed task node sequence is a cyclic sequence or that it is not. If the detection result indicates that the sequence is not a cyclic sequence, then it is actually a directed acyclic sequence, and the subsequent sorting can be directly performed based on this sequence to obtain the steps of the candidate task flow. Conversely, if the detection result indicates that the directed task node sequence is a circular sequence, the position corresponding to the lowest dependency weight in the directed task node sequence can be selected to break the sequence, thus forming a directed acyclic task node sequence. The obtained directed acyclic task node sequence is then sorted using a topology algorithm to obtain candidate task flows. Optionally, the sorting process based on the topology algorithm can be as follows: 1. Calculate the in-degree of each node in the directed acyclic task node sequence. The in-degree is the number of edges pointing to a given node. For example, if node C depends on nodes A and B, then the in-degree of node C is 2.

[0050] 2. Initialize a queue (or stack) and add all nodes with an in-degree of 0 to it. The nodes with an in-degree of 0 can be considered as the "starting point" of the task flow.

[0051] 3. Take a node (e.g., node U) from the queue. Output this node U to the topology sequence.

[0052] 4. Simulate completing this task, which involves traversing all neighboring nodes of node U. Decrement the in-degree of these neighboring nodes V by 1. If the in-degree of a neighboring node V becomes 0 as a result, add V to the queue.

[0053] 5. Repeat the above steps until the queue is empty. Check if the topology sequence contains all nodes. If the topology sequence contains all nodes, the sorting is successful, and the candidate task flow is obtained.

[0054] Understandably, the above methods can avoid the problem of infinite loops in the candidate task process and also ensure the quality of the candidate task process.

[0055] In one feasible implementation, the step of selecting conflict-free candidate task flows from each candidate task flow in the task flow set as the target task flow includes steps S321 to S322: Step S321: Detect conflicts between candidate task flows in the candidate task flow set by using preset task constraint rules. Step S322: Based on the collision detection results, select the non-conflicting candidate task flow as the target task flow.

[0056] It should be noted that after generating the candidate task process set, the candidate task processes in the candidate task process set can be further filtered.

[0057] For example, conflict detection can be performed on candidate task processes in a candidate task process set using preset task constraint rules. In a government service scenario, for instance, preset task constraint rules could include policy effective periods. Accordingly, during the screening process, if the policy effective period corresponding to a candidate task process in the candidate task process set does not match the current time, then the conflict detection result can be considered conflict-free, and the conflict-free candidate task process can be used as the target task process.

[0058] Understandably, by screening candidate task flows through the aforementioned conflict detection, the effectiveness of the final target task flow can be further guaranteed.

[0059] Reference Figure 4 This diagram illustrates the overall process of the node-based task generation method in this application. As shown, knowledge modeling is performed using Neo4j to obtain a knowledge graph (i.e., the task knowledge graph mentioned above). A pre-defined neural network model is used to extract a dependency weight matrix from the knowledge graph. After filtering out dependency weights with lower weights in the dependency weight matrix, a topological sort is applied to obtain the task flow. After the task flow is executed, execution feedback is generated for incremental updates of the knowledge graph. Simultaneously, real-time updates of policy changes can also be used for incremental updates. Incremental updates of the knowledge graph can generate a new knowledge graph and trigger retraining. Retraining refers to retraining the pre-defined neural network model. After retraining, the dependency weight matrix can be extracted from the updated knowledge graph based on the new pre-defined neural network model obtained from the retraining, thus ensuring that the final generated task flow matches the actual scenario requirements.

[0060] The following is for reference. Figure 5 It shows a schematic diagram of a structure suitable for implementing an electronic device according to the embodiments of this application. Figure 5 The electronic device shown is merely an example and should not impose any limitation on the functionality and scope of use of the embodiments of this application.

[0061] like Figure 5 As shown, the electronic device may include a processing unit 1001 (e.g., a central processing unit, a graphics processing unit, etc.), which can perform various appropriate actions and processes according to a program stored in a read-only memory (ROM) 1002 or a program loaded from a storage device 1003 into a random access memory (RAM) 1004. The RAM 1004 also stores various programs and data required for the operation of the electronic device. The processing unit 1001, ROM 1002, and RAM 1004 are interconnected via a bus 1005. An input / output (I / O) interface 1006 is also connected to the bus. Typically, the following systems can be connected to the I / O interface 1006: input devices 1007 including, for example, a touchscreen, touchpad, keyboard, mouse, image sensor, microphone, accelerometer, gyroscope, etc.; output devices 1008 including, for example, a liquid crystal display (LCD), speaker, vibrator, etc.; storage devices 1003 including, for example, magnetic tape, hard disk, etc.; and communication devices 1009. Communication device 1009 allows electronic devices to communicate wirelessly or wiredly with other devices to exchange data. Although electronic devices with various systems are shown in the figures, it should be understood that implementation or possession of all the systems shown is not required. More or fewer systems may be implemented alternatively.

[0062] Specifically, according to the embodiments disclosed in this application, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments disclosed in this application include a computer program product comprising a computer program carried on a computer-readable storage medium, the computer program containing program code for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via a communication device, or installed from storage device 1003, or installed from ROM 1002. When the computer program is executed by processing device 1001, it performs the functions defined in the methods of the embodiments disclosed in this application.

[0063] The electronic device provided in this application, employing the node-based task generation method described in the above embodiments, can solve the technical problem that current traditional task flow construction methods are unable to meet actual business needs. Compared with the prior art, the beneficial effects of the electronic device provided in this application are the same as those of the node-based task generation method provided in the above embodiments, and other technical features of this electronic device are the same as those disclosed in the previous embodiment method, and will not be repeated here.

[0064] It should be understood that the various parts disclosed in this application can be implemented using hardware, software, firmware, or a combination thereof. In the description of the above embodiments, specific features, structures, materials, or characteristics can be combined in any suitable manner in one or more embodiments or examples.

[0065] The above are merely specific embodiments of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

[0066] This application provides a computer-readable storage medium having computer-readable program instructions (i.e., a computer program) stored thereon, the computer-readable program instructions being used to execute the node-based task generation method in the above embodiments.

[0067] The computer-readable storage medium provided in this application may be, for example, a USB flash drive, but is not limited to, electrical, magnetic, optical, electromagnetic, infrared, or semiconductor systems, devices, or any combination thereof. More specific examples of computer-readable storage media may include, but are not limited to: electrical connections having one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination thereof. In this embodiment, the computer-readable storage medium may be any tangible readable storage medium that contains or stores a program that can be used by or in conjunction with an instruction execution system, system, or device. The program code contained on the computer-readable storage medium may be transmitted using any suitable readable storage medium, including but not limited to: wires, optical cables, RF (Radio Frequency), etc., or any suitable combination thereof.

[0068] The aforementioned computer-readable storage medium may be included in an electronic device or may exist independently without being assembled into an electronic device.

[0069] The aforementioned computer-readable storage medium carries one or more programs, which, when executed by an electronic device, cause the electronic device to: Construct a task knowledge graph for business scenarios, which includes information on each task node and the semantic relationships between task nodes. The dependency weight matrix of each task node is extracted from the semantic relationship information included in the task knowledge graph by using a pre-set neural network model. The dependency weight matrix is ​​used to represent the dependency relationship between each task node. The target task flow is obtained by sorting each task node by relying on the weight matrix.

[0070] Computer program code for performing the operations of this application can be written in one or more programming languages ​​or a combination thereof, including object-oriented programming languages ​​such as Java, Smalltalk, and C++, and conventional procedural programming languages ​​such as the "C" language or similar programming languages. The program code can be executed entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving remote computers, the remote computer can be connected to the user's computer via any type of network—including a Local Area Network (LAN) or a Wide Area Network (WAN)—or can be connected to an external computer (e.g., via the Internet using an Internet service provider).

[0071] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this application. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented using a dedicated hardware-based system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.

[0072] The modules described in the embodiments of this application can be implemented in software or hardware. The names of the modules do not necessarily limit the functionality of the unit itself.

[0073] The readable storage medium provided in this application is a computer-readable storage medium that stores computer-readable program instructions (i.e., a computer program) for executing the above-described node-based task generation method. This solves the technical problem that current traditional task flow construction methods are unable to meet actual business needs. Compared with the prior art, the beneficial effects of the computer-readable storage medium provided in this application are the same as those of the node-based task generation method provided in the above embodiments, and will not be elaborated upon here.

[0074] This application also provides a computer program product, including a computer program that, when executed by a processor, implements the steps of the node-based task generation method described above.

[0075] The computer program product provided in this application can solve the technical problem that current traditional task flow construction methods are unable to meet actual business needs. Compared with the prior art, the beneficial effects of the computer program product provided in this application are the same as those of the node-based task generation method provided in the above embodiments, and will not be repeated here.

[0076] The above are only some embodiments of this application and do not limit the patent scope of this application. All equivalent structural transformations made under the technical concept of this application and using the contents of the specification and drawings of this application, or direct / indirect applications in other related technical fields, are included in the patent protection scope of this application.

Claims

1. A node-based task generation method, characterized in that, The node-based task generation method includes: Construct a task knowledge graph for business scenarios, wherein the task knowledge graph includes each task node and the semantic relationship information between task nodes; A dependency weight matrix is ​​extracted from the semantic relationship information between the task nodes using a preset neural network model, wherein the dependency weight matrix is ​​used to characterize the dependency relationship between the task nodes. The task nodes are sorted using the dependency weight matrix to obtain the target task flow for the business scenario.

2. The node-based task generation method as described in claim 1, characterized in that, The node-based task generation method also includes: Entity relationships are extracted from the new information in the business scenario and / or the execution feedback of the target task process to obtain the updated graph content; The task knowledge graph is updated by updating the graph content to obtain a new task knowledge graph, and the cumulative update amount of the task knowledge graph is recorded. If the cumulative update amount of the task knowledge graph exceeds a preset cumulative threshold, the step of extracting the dependency weight matrix from the semantic relationship information between the task nodes using a preset neural network model is returned based on the new task knowledge graph; or, the preset neural network model is incrementally learned based on the new task knowledge graph to obtain a new preset neural network model, and the step of extracting the dependency weight matrix from the semantic relationship information between the task nodes using a preset neural network model is returned based on the new task knowledge graph and the new preset neural network model.

3. The node-based task generation method as described in any one of claims 1 to 2, characterized in that, The step of sorting each task node using the dependency weight matrix to obtain the target task flow of the business scenario includes: Based on the dependency weight matrix, each task node is sorted to generate a candidate task process set; From the candidate task flows in the task flow set, the candidate task flows without conflicts are selected as the target task flow.

4. The node-based task generation method as described in claim 3, characterized in that, The dependency weight matrix includes the dependency weights between any two task nodes in each task node, and the step of sorting the task nodes based on the dependency weight matrix to generate a candidate task process set includes: The dependency weights in the dependency weight matrix that are less than a preset threshold are filtered out to obtain the target dependency weight matrix; Based on the dependency weights in the target dependency weight matrix, construct a sequence of directed task nodes composed of the task nodes. Candidate task flows are determined based on the sequence of each directed task node, and the candidate task flows are combined to form the candidate task flow set.

5. The node-based task generation method as described in claim 4, characterized in that, The step of determining the candidate task process based on the sequence of directed task nodes includes: Detect any of the directed task node sequences; If the detection result indicates that the directed task node sequence is a circular sequence, the position corresponding to the lowest dependency weight in the directed task node sequence is disconnected to form a directed acyclic task node sequence. The directed acyclic task node sequence is sorted using a topology algorithm to obtain candidate task flows.

6. The node-based task generation method as described in claim 3, characterized in that, The step of selecting conflict-free candidate task flows from each candidate task flow in the task flow set as the target task flow includes: Conflict detection is performed between the candidate task processes in the candidate task process set by using preset task constraint rules. Based on the conflict detection results, conflict-free candidate task flows are selected as the target task flow.

7. The node-based task generation method as described in claim 1, characterized in that, The step of extracting the dependency weight matrix from the semantic relationship information between the task nodes using a preset neural network model includes: The task knowledge graph, including the semantic relationship information, is input into the preset neural network model to obtain the dependency weight matrix of each task node. The preset neural network model is used to aggregate the neighbor node features of each task node in the task knowledge graph based on the semantic relationship information, and to identify the dependency weight matrix based on the neighbor node features of each task node.

8. An electronic device, characterized in that, The electronic device includes: a processor, a memory, and a node-based task generation program stored in the memory and executable on the processor, wherein the node-based task generation program, when executed, implements the steps of the node-based task generation method as described in any one of claims 1-7.

9. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a node-based task generation program, which, when executed, implements the steps of the node-based task generation method as described in any one of claims 1-7.

10. A computer program product, characterized in that, The computer program product includes a node-based task generation program, which, when executed by a processor, implements the steps of the node-based task generation method as described in any one of claims 1-7.

Images