Method and system for automatically generating and assigning virtual workplace tasks based on knowledge graph

Abstract

The application provides a knowledge graph-based virtual workplace task automatic generation and distribution method and system, relates to the technical field of virtual workplace, and comprises the following steps: constructing a multi-level workplace knowledge graph, performing semantic analysis on task information and recursively decomposing the task information, combining a candidate performer ability portrait, and realizing autonomous negotiation distribution and dynamic adjustment of the task. The method can improve the virtual workplace task distribution efficiency, optimize resource utilization, enhance the flexibility and adaptability of task execution, and reduce the management cost.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of virtual workplace, and in particular to a virtual workplace task automatic generation and distribution method and system based on a knowledge graph. BACKGROUND

[0002] With the deepening of digital transformation, virtual workplace as a new work mode is gradually being widely applied. Task management in virtual workplace involves key links such as task generation, decomposition and distribution, which is of great significance to improve work efficiency and collaboration quality. Traditional virtual workplace task management mainly relies on manual experience for planning and distribution, which is difficult to cope with complex and variable work scenarios.

[0003] The prior art lacks systematic modeling of complex dependency relationships between tasks, and cannot accurately express the preconditions, resource competition and timing constraints between tasks, resulting in frequent conflicts in the actual execution of the generated task decomposition scheme. Secondly, the traditional task allocation method usually adopts static rule matching or simple ability scoring mechanism, and does not fully consider the historical performance, professional skill development track and team collaboration characteristics of the executors, resulting in mismatch between task allocation and actual ability, and reducing the overall work efficiency. SUMMARY

[0004] The embodiment of the present application provides a virtual workplace task automatic generation and distribution method and system based on a knowledge graph, which can solve the problems in the prior art.

[0005] The first aspect of the embodiment of the present application provides a virtual workplace task automatic generation and distribution method based on a knowledge graph, comprising:

[0006] Obtaining task information in a virtual workplace, constructing a multi-level workplace knowledge graph including a task layer and a role layer, wherein the task layer contains task type nodes and inter-task pre-dependence relationships, and the role layer contains execution role nodes and role collaboration relationships;

[0007] Converting the task information into a word vector based on the multi-level workplace knowledge graph, constructing a k-neighbor graph structure based on the word vector, performing local information diffusion on the word vector through random walk, and generating task semantic features; recursively decomposing the task semantic features, decomposing the overall task target into multiple sub-targets, combining the sub-targets based on the dependency relationships in the multi-level workplace knowledge graph, decomposing the time complexity and resource dependency relationships of each sub-task in the decomposition tree, and generating a task decomposition graph;

[0008] The historical task data of the candidate performer is acquired from the virtual workplace task execution system, the capability profile of the candidate performer is constructed, the candidate performer is taken as an execution unit with autonomous decision-making capability according to the capability profile, a task allocation scheme is generated through task negotiation and bidding between execution units in combination with the dependency relationship constraint of the task decomposition graph, and the allocation scheme is dynamically adjusted according to the execution condition in the task execution process.

[0009] The multi-level workplace knowledge graph including a task layer and a role layer is constructed, including:

[0010] The task layer includes a task type node set and a task dependency relationship edge set, the role layer includes an execution role node set and a role collaboration relationship edge set, each edge in the task dependency relationship edge set connects the associated task type node, and each edge in the role collaboration relationship edge set connects the execution role nodes with a collaboration relationship;

[0011] The collaboration strength weight of each edge in the role collaboration relationship edge set is calculated based on role collaboration historical data, the collaboration strength weight is calculated by weighted calculation of the normalized value of the collaboration times and the normalized value of the collaboration effect score, and the collaboration effect score is evaluated based on the completion quality of the historical collaboration task;

[0012] The task attribute features and the role attribute features are respectively subjected to vector transformation, the correlation degree between the transformed feature vectors is calculated to obtain a node pair correlation degree, and the node pair correlation degree represents the association degree between the task type node and the execution role node.

[0013] The task information is converted into a word vector based on the multi-level workplace knowledge graph, a k-neighbor graph structure is constructed based on the word vector, local information diffusion is performed on the word vector in a random walk manner, and the task semantic features include:

[0014] The word sequence in the task description text of the task information is converted into a word vector;

[0015] The semantic mutual information between the word vectors is calculated, the semantic mutual information is calculated through feature transformation and interaction matrix of the word vector, a k-neighbor graph structure is constructed based on the semantic mutual information, the connection relationship between each word vector and its k most similar nodes is reserved, and a decay weight is assigned to the reserved connection relationship, the decay weight is obtained by distance weighting of the semantic mutual information through a Gaussian kernel function;

[0016] Multi-hop feature propagation is performed based on the decay weight of the connection relationship, local information diffusion is performed on the word vector in a random walk manner, and task semantic features are generated.

[0017] The sub-targets are combined based on the dependency relationship in the multi-level job knowledge graph, the time complexity and resource dependency relationship of each sub-task in the tree are decomposed, and a task decomposition graph is generated, including:

[0018] The correlation degree of the sub-targets is analyzed according to the dependency relationship, the sub-targets with a correlation degree higher than a preset correlation degree threshold are combined to form a plurality of sub-target combination sets, the execution cost of each sub-target in the sub-target combination set is calculated according to the predicted execution time and resource occupation of the sub-target, and the sub-target combination with the lowest execution cost and meeting the preset dependency strength requirement is selected as the optimal combination scheme;

[0019] The input size and single operation time consumption of the sub-targets in the optimal combination scheme are obtained, the fixed overhead time in the task execution process is determined, and the time complexity of each sub-target is calculated based on the input size, the single operation time consumption and the fixed overhead time;

[0020] A dependency relationship matrix of tasks and resources is constructed based on the time complexity, the dependency relationship matrix records the dependency degree of each task on various resources, and a task decomposition graph is generated according to the dependency relationship matrix.

[0021] According to the ability portrait, the candidate executors are taken as execution units with autonomous decision-making ability, through task negotiation and bidding between execution units, and in combination with the dependency relationship constraint of the task decomposition graph, a task allocation scheme is generated, including:

[0022] A state vector of the execution unit is constructed, the state vector includes an image vector corresponding to the ability portrait and a load level index, and the utility value of the execution unit to the task is calculated based on the matching degree of the image vector and the task demand and the load level index;

[0023] A bidding function of the execution unit is constructed based on the utility value, the bidding function is calculated by the product of the utility value and an exponential decay term of the execution cost, and the execution cost includes a weighted combination of time delay cost and load transfer cost;

[0024] The current load state and the remaining resource amount of the execution unit are normalized and then weighted and summed to obtain a resource consumption score, the resource consumption score and the bid value output by the bidding function are matched to calculate a task allocation probability, and a task allocation scheme is generated in combination with the dependency relationship constraint of the task decomposition graph.

[0025] The resource consumption score and the bid value output by the bidding function are matched to calculate a task allocation probability, and a task allocation scheme is generated in combination with the dependency relationship constraint of the task decomposition graph, including:

[0026] When multiple tasks with dependencies are assigned to different execution units, the task assignment probability is penalized according to the communication overhead between execution units, and the task assignment probability is reduced; when multiple tasks with dependencies are assigned to the same execution unit, the task assignment probability is rewarded according to the parallelism of the task, and the task assignment probability is increased.

[0027] A task assignment scheme is generated according to the adjusted task assignment probability, and the task assignment scheme determines the target execution unit of each task and records the execution order of the task and the resource allocation information.

[0028] The second aspect of the embodiment of the application provides a virtual workplace task automatic generation and distribution system based on a knowledge graph, which comprises:

[0029] The first unit is configured to obtain task information in a virtual workplace, and construct a multi-level workplace knowledge graph comprising a task layer and a role layer, wherein the task layer comprises task type nodes and inter-task precedence dependency relationships, and the role layer comprises execution role nodes and role collaboration relationships.

[0030] The second unit is configured to convert the task information into a word vector based on the multi-level workplace knowledge graph, construct a k-nearest neighbor graph structure based on the word vector, perform local information diffusion on the word vector in a random walk manner, generate task semantic features, recursively decompose the task semantic features, decompose an overall task target into multiple sub-targets, combine the sub-targets based on the dependency relationships in the multi-level workplace knowledge graph, decompose the time complexity and resource dependency relationships of each sub-task in the decomposition tree, and generate a task decomposition graph.

[0031] The third unit is configured to obtain historical task data of candidate executors from a virtual workplace task execution system, construct a capability profile of the candidate executors, use the candidate executors as execution units with autonomous decision-making capabilities according to the capability profile, generate a task assignment scheme through task negotiation and bidding between the execution units, in combination with the dependency relationship constraints of the task decomposition graph, and dynamically adjust the assignment scheme according to the execution during the task execution process.

[0032] The third aspect of the embodiment of the application,

[0033] An electronic device is provided, comprising:

[0034] a processor;

[0035] a memory for storing processor-executable instructions;

[0036] The processor is configured to invoke the instructions stored in the memory to execute the method described above.

[0037] The fourth aspect of the embodiment of the application,

[0038] A computer readable storage medium is provided, which stores computer program instructions, and the computer program instructions are executed by a processor to implement the method.

[0039] The beneficial effects of the present application are as follows:

[0040] The present application realizes the structured representation of task information by constructing a multi-level job knowledge graph, converts abstract job tasks into executable units with clear semantic features, and improves the accuracy of task understanding and processing.

[0041] The present application adopts a recursive decomposition method to refine tasks, forms a task decomposition graph based on the dependency relationship in the knowledge graph, reasonably splits complex tasks into manageable subtasks while maintaining the logical association between tasks, and optimizes task planning and execution efficiency.

[0042] The present application introduces an autonomous decision mechanism based on the ability portrait of the performer, realizes intelligent allocation of tasks through task negotiation and bidding between execution units, and can dynamically adjust according to the execution situation, improves resource utilization and task completion quality, and makes virtual job management more flexible and efficient. BRIEF DESCRIPTION OF DRAWINGS

[0043] Figure 1 The flowchart of the virtual job task automatic generation and distribution method based on the knowledge graph of the embodiment of the present application is shown.

[0044] Figure 2 The flowchart of generating a task allocation scheme is shown. DETAILED DESCRIPTION

[0045] To make the purpose, technical scheme and advantages of the embodiments of the present application clearer, the technical scheme in the embodiments of the present application will be described clearly and completely below in combination with the drawings in the embodiments of the present application. Obviously, the described embodiments are only part of the embodiments of the present application, not all the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those skilled in the art without creative labor fall within the scope of protection of the present application.

[0046] The technical scheme of the present application will be described in detail below with specific embodiments. The following specific embodiments can be combined with each other, and the same or similar concepts or processes may not be described in some embodiments.

[0047] Reference Figure 1 and Figure 2 The virtual job task automatic generation and distribution method based on the knowledge graph comprises:

[0048] Acquire task information in a virtual workplace, and construct a multi-level workplace knowledge graph including a task layer and a role layer, wherein the task layer includes task type nodes and pre-requisite dependency relationships between tasks, and the role layer includes execution role nodes and role collaboration relationships;

[0049] Convert the task information into wordpiece vectors based on the multi-level workplace knowledge graph, construct a k-nearest neighbor graph structure based on the wordpiece vectors, perform local information diffusion on the wordpiece vectors in a random walk manner, and generate task semantic features; recursively decompose the task semantic features, decompose an overall task target into multiple sub-targets, combine the sub-targets based on dependency relationships in the multi-level workplace knowledge graph, decompose the time complexity and resource dependency relationships of each sub-task in the decomposition tree, and generate a task decomposition graph;

[0050] Acquire historical task data of candidate executors from a virtual workplace task execution system, construct an ability profile of the candidate executors, and according to the ability profile, take the candidate executors as execution units with autonomous decision-making capabilities, generate a task allocation scheme through task negotiation and bidding between the execution units in combination with dependency relationship constraints of the task decomposition graph, and dynamically adjust the allocation scheme according to execution conditions during task execution.

[0051] In an optional implementation, constructing a multi-level workplace knowledge graph including a task layer and a role layer includes:

[0052] The task layer includes a task type node set and a task dependency relationship edge set, the role layer includes an execution role node set and a role collaboration relationship edge set, each edge in the task dependency relationship edge set connects associated task type nodes, and each edge in the role collaboration relationship edge set connects execution role nodes having a collaboration relationship;

[0053] Calculate a collaboration strength weight of each edge in the role collaboration relationship edge set based on role collaboration historical data, wherein the collaboration strength weight is calculated by weighting a normalized value of a collaboration frequency and a normalized value of a collaboration effect score, and the collaboration effect score is evaluated based on completion quality of historical collaboration tasks;

[0054] Perform vector transformation on task attribute features and role attribute features respectively, calculate a correlation degree between the transformed feature vectors to obtain a node pair correlation degree, and the node pair correlation degree represents an association degree between a task type node and an execution role node.

[0055] The construction process of the multi-level job knowledge graph includes three steps: data collection, node generation, and relationship modeling. In the data collection stage, the enterprise's internal task execution records, role information, and historical collaboration data are obtained. The task execution records include task identification, task type, start time, end time, participating roles, and completion status. The role information includes role identification, role name, skill list, and historical performance. The historical collaboration data includes the identification of the collaborating roles, the identification of the collaboration task, the collaboration duration, and the collaboration score.

[0056] In the node generation step, the system creates a set of task type nodes for the task layer and a set of execution role nodes for the role layer based on the collected data. The task type nodes are generated by analyzing historical task records to extract key features. For example, when a "data analysis" task appears in the historical data, the system creates a "data analysis" task type node and extracts attributes such as the average execution duration, resource consumption, and completion difficulty of this type of task. The execution role nodes are generated based on the enterprise organizational structure and personnel information. For example, for the "data analyst" role, the system creates a corresponding node and records attributes such as professional skills, historical task completion rate, and average task quality score.

[0057] In the relationship modeling step, the system constructs a set of task dependency relationship edges and a set of role collaboration relationship edges. The task dependency relationship edges are determined based on the order of task execution. For example, when the "data preprocessing" task is usually executed before the "model training" task, the system establishes a directed edge between the two task type nodes and marks the dependency strength. The role collaboration relationship edges are generated based on historical collaboration records. For example, if the "data analyst" and "product manager" have frequent collaboration records in multiple projects, the system establishes an undirected edge between the two role nodes.

[0058] The collaboration strength weight calculation of the role collaboration relationship edge involves two key indicators: collaboration frequency and collaboration effect score. The collaboration frequency is obtained by counting the number of tasks that two roles have participated in together in a certain period of time (e.g., the past 6 months). For example, if role A and role B have completed 15 tasks together in the past 6 months, and the system records the highest collaboration frequency as 30, then the normalized value of the collaboration frequency is 0.5. The collaboration effect score is obtained by analyzing the quality assessment of the tasks completed together, including task completion timeliness, result quality, and communication efficiency. Assuming that the average score of the tasks completed by role A and role B together is 85 points (out of 100), then the normalized value of the collaboration effect score is 0.85.

[0059] The calculation of the collaboration intensity weight adopts a weighted average method, and weight coefficients are assigned to the collaboration frequency normalized value and the collaboration effect score normalized value. In actual application, the weight proportion can be adjusted according to the business characteristics. For example, in a scenario with high quality requirements, the collaboration effect score weight can be set to 0.7, and the collaboration frequency weight can be set to 0.3; in a scenario with high efficiency requirements, the weights of the two can be set to 0.5. Assuming that equal weights of 0.5 are adopted, the collaboration intensity weight between role A and role B in the above example is 0.5 x 0.5 + 0.5 x 0.85 = 0.675.

[0060] The association degree calculation between the task type node and the execution role node is the key to the cross-layer connection of the knowledge graph. This process first performs vector transformation on the task attribute features and the role attribute features. The task attribute features include task complexity, required professional knowledge, expected completion time, and resource demand dimensions; the role attribute features include professional skills, historical performance, handled task types, and resource control ability dimensions.

[0061] In the vector transformation process, the system converts the above features into fixed-dimension numerical vectors. For example, for the "data analysis" task, the complexity is medium (0.6), the required professional knowledge is data mining and statistical analysis (after vectorization, [0.8, 0.7]), the expected completion time is 3 days (after normalization, 0.5), and the resource demand is computing resources and storage resources (after vectorization, [0.7, 0.4]). Combine these values and convert them into a 16-dimensional vector through an embedding algorithm. Similarly, for the "data analyst" role, the professional skills are data mining and visualization (after vectorization, [0.9, 0.6]), the historical performance score is 90 points (after normalization, 0.9), the main handled task types are data cleaning and feature engineering (after vectorization, [0.8, 0.7]), and the resource control ability is computing resources and analysis tools (after vectorization, [0.8, 0.6]). Similarly, convert them into a 16-dimensional vector through an embedding algorithm.

[0062] The node pair relevance calculation adopts a vector similarity measurement method. The system calculates the cosine similarity of the task feature vector and the role feature vector, and the closer the cosine value is to 1, the higher the matching degree of the task and the role. For example, the feature vector similarity calculation result of the "data analysis" task and the "data analyst" role is 0.85, indicating a high degree of match; while the similarity with the "front-end development engineer" role is only 0.3, indicating a lower degree of match. The system sets a relevance threshold (such as 0.6), and when the node pair relevance exceeds the threshold, a cross-layer connection edge is established in the knowledge graph, and the relevance value is taken as the weight of the edge.

[0063] In actual application scenarios, the system regularly updates the node attributes and edge weights in the knowledge graph. When new task execution records are generated, the system analyzes the task completion and adjusts the attribute values of the task type nodes; when a role performs a new task and obtains an evaluation, the system updates the skill level and performance indicators of the role nodes; when two roles complete a new collaborative task, the system recalculates the collaboration strength weight. For example, if roles A and B collaborate to complete a task and obtain a high evaluation of 95 points, the system will incorporate the new data into the calculation, causing the collaboration strength weight to increase to 0.7.

[0064] When the system assigns tasks using the multi-level workplace knowledge graph, it first finds similar task type nodes in the task layer according to the characteristics of the new task; then it finds a set of execution role nodes with high matching degrees to the task type by the node relevance; and finally, it selects the optimal role combination to complete the task by considering the current load of the roles and the collaboration strength between the roles. For example, for a new "customer data analysis" task, the system identifies a similarity of 0.9 between it and the "data analysis" task type, and then finds a "data analyst" role with a high matching degree, and considers the high collaboration strength between the role and the "product manager", and assigns the task to these two roles to complete collaboratively.

[0065] In an optional implementation, the task information is converted into word vector based on the multi-level workplace knowledge graph, a k-neighbor graph structure is constructed based on the word vector, and local information diffusion is performed on the word vector by random walk to generate task semantic features, which include:

[0066] The word sequence in the task description text of the task information is converted into a word vector;

[0067] The semantic mutual information between the word vectors is calculated, the semantic mutual information is calculated through feature transformation and interaction matrix of the word vector, a k-neighbor graph structure is constructed based on the semantic mutual information, the connection relationship between each word vector and its k most similar nodes is retained, and a decay weight is assigned to the retained connection relationship, the decay weight is obtained by distance weighting of the semantic mutual information through a Gaussian kernel function;

[0068] Multi-hop feature propagation is performed based on the decay weight of the connection relationship, local information diffusion is performed on the word vector by random walk to generate task semantic features.

[0069] In this embodiment, the task information is converted into a word vector, then a k-neighbor graph structure is constructed based on the word vector, and finally local information diffusion is performed on the word vector by random walk to generate task semantic features.

[0070] A multi-level workplace knowledge graph contains entity, relationship, and attribute information within the workplace domain. Entities can be skills, positions, industries, etc., while relationships can be "needed," "belongs to," "related," etc. This knowledge graph is organized through a multi-level structure, enabling it to express workplace knowledge at different granularities. For example, for a software development task, the knowledge graph can provide relevant knowledge at multiple levels, from programming languages, frameworks, and development tools to project management methodologies.

[0071] The process of converting task information into word vectors includes two steps: text preprocessing and vectorization. In the text preprocessing stage, the system performs operations such as word segmentation and stop word removal on the task description text. For example, for the task description "Develop a customer churn prediction system based on machine learning," the system decomposes it into words such as "develop," "machine learning," "customer churn," "predict," and "system." In the vectorization stage, the system maps each word to a pre-trained word vector space, obtaining the corresponding word vector. Assuming a 300-dimensional word vector space is used, each word will be represented as a 300-dimensional floating-point vector. For the word "machine learning" in the above task description, its vector representation is [0.23, 0.45, -0.12, ..., 0.67].

[0072] The calculation of semantic mutual information between lexical vectors is fundamental to constructing the k-nearest neighbor graph structure. Semantic mutual information is obtained through feature transformation of lexical vectors and calculation of the interaction matrix. Specifically, a nonlinear transformation function is applied to each lexical vector to enhance its expressive power. For example, for a lexical vector v, the hyperbolic tangent function can be applied to transform it, resulting in the transformed vector v'. Then, the interaction matrix between any two transformed lexical vectors v_i' and v_j' is calculated. This matrix reflects the relationship between the two lexical vectors in different dimensions. The semantic mutual information value is calculated based on the interaction matrix; a higher value indicates a stronger semantic association between the two lexical vectors. For example, the semantic mutual information value between "machine learning" and "prediction" is 0.85, while the value between "machine learning" and "system" is 0.62.

[0073] When constructing a k-nearest neighbor graph structure based on semantic mutual information, the connections between each word vector and its k most similar nodes are preserved. In practical applications, the value of k can be adjusted according to task complexity and the number of words, generally ranging from 5 to 15. For example, when k=10, for the word "machine learning," connections between it and the 10 words with the highest semantic mutual information values ​​are preserved. These preserved connections are assigned decay weights, obtained by distance-weighting the semantic mutual information using a Gaussian kernel function. Specifically, the Gaussian kernel function converts the semantic mutual information values ​​into weight values ​​between 0 and 1; the higher the semantic mutual information, the closer the corresponding weight is to 1. For example, the connection between "machine learning" and "prediction," with a semantic mutual information value of 0.85, has a weight of 0.92; while the connection between "machine learning" and "system," with a semantic mutual information value of 0.62, has a weight of 0.74.

[0074] Multi-hop feature propagation based on decaying weights of connectivity relationships is achieved through random walks. A random walk is a method that simulates information propagation in a graph structure. It starts from a node and randomly selects the next node to visit based on the edge weights, repeating this process to form a path. In this embodiment, multiple random walks are performed starting from each word vector node, with each walk consisting of 3 to 5 steps. For example, starting from the "machine learning" node, a walk is performed following the path "machine learning" → "prediction" → "customer churn" → "system". During the walk, the transition probability is adjusted based on the decaying weights of the edges; edges with higher weights have a greater probability of being selected.

[0075] By performing multiple random walks, local contextual information for each lexical vector node can be obtained. The system aggregates this information to generate a context-enhanced representation for each lexical. For example, for the lexical "machine learning," its context-enhanced representation would include information from related lexicals such as "prediction" and "customer churn." A weighted average of the context-enhanced representations of all lexical elements is then taken to obtain the semantic feature representation of the entire task. This representation effectively captures the complex semantic relationships between lexical elements in the task description, providing strong support for subsequent task matching and recommendation.

[0076] The above method can convert the original task description text into a vector representation with rich semantic information. This representation not only considers the semantics of the word itself, but also integrates the relationship between words, thus more comprehensively depicting the semantic connotation of the task.

[0077] In one optional implementation, sub-goals are combined based on dependencies in a multi-level workplace knowledge graph, and the time complexity and resource dependencies of each sub-task in the decomposition tree are decomposed to generate a task decomposition graph, including:

[0078] Based on the dependencies, the sub-targets are analyzed for correlation. Sub-targets with correlation higher than a preset correlation threshold are combined to form multiple sub-target combination sets. The execution cost of each sub-target is calculated based on the expected execution time and resource consumption of each sub-target in the sub-target combination set. The sub-target combination with the lowest execution cost and meeting the preset dependency strength requirement is selected as the optimal combination scheme.

[0079] For the sub-objectives in the optimal combination scheme, obtain the task input size and single operation time, determine the fixed overhead time during task execution, and calculate the time complexity of each sub-objective based on the input size, the single operation time and the fixed overhead time;

[0080] Based on the time complexity, a dependency matrix of tasks and resources is constructed. The dependency matrix records the degree of dependence of each task on various types of resources. A task decomposition graph is generated based on the dependency matrix.

[0081] In practical applications, a dependency network between sub-goals is constructed using a workplace knowledge graph. This network includes three main dependency types: semantic dependency, structural dependency, and temporal dependency. Semantic dependency represents the degree of relevance of sub-goals in terms of business meaning, obtained by analyzing the functional mapping relationship between skill nodes and task nodes; structural dependency represents the sequential order of sub-goals in the execution process, obtained through the execution paths between task nodes; and temporal dependency represents the temporal correlation of sub-goals in resource usage, obtained through the order in which resource nodes are invoked.

[0082] After the dependency network is constructed, a correlation analysis is performed on the sub-objectives. The correlation calculation method is based on a weighted summation of dependency strength, with a preset correlation threshold of 0.6. When the correlation between sub-objectives exceeds this threshold, they are grouped into the same set. For all sub-objectives in the network, the correlation of each pair of sub-objectives is calculated through traversal, forming multiple sets of sub-objective combinations. Taking a project containing 10 sub-objectives as an example, correlation analysis forms 3 sets of sub-objective combinations: Set 1 contains sub-objectives A, B, and C; Set 2 contains sub-objectives D, E, F, and G; Set 3 contains sub-objectives H, I, and J.

[0083] For each set of sub-objectives, the execution cost is calculated, consisting of execution time and resource consumption. Execution time is estimated using historical data or expert experience, while resource consumption includes multi-dimensional indicators such as computing resources, storage resources, and network resources. Weighting coefficients are assigned to different resource types to calculate the overall resource consumption. For example, for sub-objective A in set 1, its estimated execution time is 8 hours, computing resource consumption is CPU cores × usage time = 4 cores × 8 hours = 32 cores, storage resource consumption is 500GB, and network resource consumption is bandwidth × transmission time = 100Mbps × 2 hours = 720GB. The execution cost of sub-objective A can be expressed as the product of execution time and resource consumption. Similarly, the execution costs of other sub-objectives within the set are calculated, and the summation yields the total execution cost of the set.

[0084] It is also necessary to consider whether the combination of sub-objectives meets the preset dependency strength requirements. These requirements specify the minimum dependency strength between sub-objectives within a combined set and the maximum dependency strength between sub-objectives in different combined sets. For example, the average dependency strength between sub-objectives within a set must be no less than 0.65, and the maximum dependency strength between sub-objectives in different sets must not exceed 0.4. The total execution cost of each combination scheme is calculated, and schemes that meet the dependency strength requirements are selected. The scheme with the lowest execution cost is chosen as the optimal combination scheme.

[0085] For each sub-objective in the determined optimal combination scheme, its time complexity is further calculated. Time complexity calculation requires three key parameters: task input size, single operation time, and fixed overhead time. Task input size refers to the amount of data or number of operations processed by the sub-objective; single operation time refers to the time required to process a unit of data; and fixed overhead time refers to the preparation time independent of the input size. These parameters are obtained through historical execution data or prototype testing. For example, for a data processing sub-objective, the input size might be the number of records to be processed, such as 1 million; the single operation time is the average time to process one record, such as 0.5 milliseconds; and the fixed overhead time includes data loading and initialization time, such as 30 seconds. Based on these parameters, the system can represent the time complexity of this sub-objective as the fixed overhead time plus the input size multiplied by the single operation time. In this way, a time complexity model is established for each sub-objective in the optimal combination scheme.

[0086] Based on the calculated time complexity, the system constructs a dependency matrix between tasks and resources. This matrix is ​​a two-dimensional table where rows represent sub-goals, columns represent various resources, and matrix element values ​​represent the degree of dependency of a sub-goal on a resource. The degree of dependency is calculated through the relationship between the time complexity of a sub-goal and resource utilization efficiency. For example, if the time complexity of sub-goal A is highly dependent on CPU computing power, its dependency on computing resources is high, which can be 0.8; if the access frequency to storage resources is low, its dependency on storage resources can be 0.3. The system determines the calculation method for the degree of dependency based on business rules and historical data analysis, generating a complete dependency matrix. Taking a project containing 5 sub-objectives and 3 types of resources as an example, its dependency matrix can be as follows: Sub-objective A has a dependency of 0.8, 0.3, and 0.5 on computing resources, storage resources, and network resources, respectively; Sub-objective B has a dependency of 0.6, 0.7, and 0.2; Sub-objective C has a dependency of 0.4, 0.9, and 0.3; Sub-objective D has a dependency of 0.7, 0.4, and 0.8; Sub-objective E has a dependency of 0.5, 0.6, and 0.7.

[0087] After the dependency matrix is ​​constructed, a task decomposition graph is generated based on it. The task decomposition graph is a directed graph structure where nodes represent sub-goals and edges represent dependencies between sub-goals. The resource competition for each sub-goal is determined based on the dependency matrix, and the resource conflict degree between sub-goals is calculated. Sub-goals with high resource conflict degrees are generally not suitable for parallel execution. Combining the previously analyzed semantic, structural, and temporal dependencies, as well as the resource conflict situation, the overall dependency relationship between sub-goals is determined. For example, if sub-goal A and sub-goal B have high resource conflict (e.g., both depend on the same computing resource) and a structural dependency exists, a directed edge from A to B is established in the task decomposition graph, indicating that B depends on the completion of A. All sub-goal pairs are analyzed to construct a complete directed graph structure.

[0088] After the task decomposition diagram is generated, it visually displays each sub-objective and its dependencies, supporting project managers in task planning and resource allocation. When task status changes or resource configuration is adjusted during actual execution, the dependency matrix and task decomposition diagram are updated in real time, ensuring the rationality of the task execution plan and the efficiency of resource utilization. This task decomposition method based on a multi-level workplace knowledge graph enables intelligent breakdown and optimized combination of complex projects, improving project execution efficiency and resource utilization.

[0089] In one optional implementation, candidate executors are identified as execution units with autonomous decision-making capabilities based on the capability profile. A task allocation scheme is generated through task negotiation and bidding among execution units, combined with the dependency constraints of the task decomposition graph, including:

[0090] Construct a state vector for the execution unit, which includes a profile vector corresponding to the capability profile and a load level index. Calculate the utility value of the execution unit for the task based on the matching degree between the profile vector and the task requirements and the load level index.

[0091] The bidding function of the execution unit is constructed based on the utility value. The bidding function is calculated by multiplying the utility value by the exponential decay term of the execution cost. The execution cost includes a weighted combination of time delay cost and load transfer cost.

[0092] The current load status and remaining resource amount of the execution unit are normalized and then weighted and summed to obtain the resource consumption score. The resource consumption score is matched with the bid value output by the bidding function to obtain the task allocation probability. Combined with the dependency constraints of the task decomposition graph, a task allocation scheme is generated.

[0093] In this embodiment, candidate executors are treated as execution units with autonomous decision-making capabilities. Through task negotiation and bidding among execution units, combined with the dependency constraints of the task decomposition graph, a task allocation scheme is generated.

[0094] In the specific implementation method, a state vector of the execution unit is constructed. The state vector contains a profile vector corresponding to the capability profile and a load level index. The profile vector describes the skill characteristics of the execution unit, including multi-dimensional attributes such as technical field identifier, professional level, years of experience, response speed, and quality score. Taking a software development team as an example, the profile vector of execution unit A can be represented as front-end development precision 0.9, back-end development precision 0.6, testing capability 0.5, project management capability 0.7, etc. The load level index reflects the current task load of the execution unit, including the ratio of the number of assigned tasks to the maximum capacity. For example, if execution unit A currently undertakes 3 tasks and its maximum capacity is 5 tasks, then its load level index is 0.6.

[0095] After constructing the state vector, the utility value of the execution unit for the task is calculated. The utility value is based on the matching degree between the profile vector and the task requirements, as well as the load level index. The matching degree is calculated using the cosine similarity method, comparing the task requirement vector with the execution unit profile vector. For example, a development task requirement vector has front-end development requirements of 0.8, back-end development requirements of 0.4, and testing requirements of 0.3, and the matching degree calculated with the profile vector of execution unit A is 0.85. The load level index is transformed using an exponential function, so that the higher the load, the lower the utility value. For execution unit A with a load level index of 0.6, the transformed load adjustment factor is 0.75. The final utility value is the product of the matching degree and the load adjustment factor, i.e., 0.85 × 0.75 = 0.6375.

[0096] The bidding function for execution units is constructed based on utility values. The bidding function is calculated by multiplying the utility value by an exponentially decaying term of the execution cost. Execution cost comprises a weighted combination of time delay cost and load balancing cost. Time delay cost reflects the difference between the estimated time required to execute a task and its expected completion time. For example, if a task is expected to be completed in 3 days, and execution unit A is expected to take 4 days, then the time delay is 1 day, and the corresponding time delay cost can be set to 0.2. Load balancing cost measures the impact of receiving a new task on the existing tasks of the execution unit. For example, after receiving a new task, the load level of execution unit A will increase from 0.6 to 0.8, and the load balancing cost can be set to 0.15. Assuming the weights of time delay cost and load balancing cost are 0.6 and 0.4 respectively, the execution cost is 0.2 × 0.6 + 0.15 × 0.4 = 0.18.

[0097] With the exponential decay factor set to 2.5, the competition value of execution unit A for this task is calculated as: 0.6375 × exponential decay term, where the exponential decay term is 2.718 raised to the power of -0.18 × 2.5, approximately equal to 0.64. Therefore, the competition value is 0.6375 × 0.64 = 0.408.

[0098] Next, the current load status and remaining resource amount of the execution unit are normalized and then weighted and summed to obtain the resource consumption score. Assume that execution unit A has a CPU utilization of 50%, memory usage of 40%, and bandwidth usage of 30%, which, after normalization, are 0.5, 0.4, and 0.3 respectively. Setting the weights of these three resource items to 0.5, 0.3, and 0.2 respectively, the resource consumption score is 0.5 × 0.5 + 0.4 × 0.3 + 0.3 × 0.2 = 0.43.

[0099] The task allocation probability is obtained by matching the resource consumption score with the bidding value output by the bidding function. The calculation method is to divide the bidding value by the product of the resource consumption score and the adjustment factor. Assuming the adjustment factor is 1.2, the task allocation probability is 0.408 / (0.43×1.2)=0.79.

[0100] Repeat the above calculation process for all execution units in the system to obtain the allocation probability of each execution unit for a specific task. For example, the allocation probabilities of execution units A, B, and C for task 1 are 0.79, 0.62, and 0.45, respectively.

[0101] Finally, the task allocation scheme is generated by combining the dependency constraints of the task decomposition graph. The task decomposition graph describes the dependencies between tasks; for example, task 2 depends on the completion of task 1, and tasks 3 and 4 depend on the completion of task 2. The dependency constraints require that interdependent tasks should be assigned to combinations of execution units with high collaboration efficiency as much as possible. By calculating the collaboration efficiency matrix between execution units and combining it with the task dependency graph, an iterative optimization method is used to generate the final allocation scheme. For example, if the collaboration efficiency between execution unit A and execution unit B is 0.85, which is higher than the collaboration efficiency between A and C (0.62), then if task 1 is assigned to execution unit A, task 2 is more likely to be assigned to execution unit B.

[0102] The final task allocation scheme includes: task 1 is assigned to execution unit A (probability 0.79), task 2 is assigned to execution unit B (probability 0.82, taking into account the collaboration efficiency with A), task 3 is assigned to execution unit A (probability 0.71), and task 4 is assigned to execution unit C (probability 0.68).

[0103] By employing the aforementioned technologies, this method can automatically generate an efficient task allocation scheme based on the capability profile of the execution unit, its load status, and the dependencies between tasks, thereby improving the overall execution efficiency of the system.

[0104] In one optional implementation, the task allocation probability is obtained by calculating the matching degree between the resource consumption score and the bid value output by the bidding function, and then, combined with the dependency constraints of the task decomposition graph, a task allocation scheme is generated, including:

[0105] When multiple tasks with dependencies are assigned to different execution units, the task assignment probability is penalized based on the communication overhead between execution units, thus reducing the task assignment probability; when multiple tasks with dependencies are assigned to the same execution unit, the task assignment probability is rewarded based on the parallelism of the tasks, thus increasing the task assignment probability.

[0106] A task allocation scheme is generated based on the adjusted task allocation probability. The task allocation scheme determines the target execution unit for each task and records the execution order and resource allocation information of the tasks.

[0107] This invention provides a method for calculating the task allocation probability by matching the resource consumption score with the bidding value output by the bidding function, and generating a task allocation scheme by combining the dependency constraints of the task decomposition graph.

[0108] For each execution unit in the system, such as different processor cores or computing nodes, calculate its resource consumption score when handling various tasks. The resource consumption score can be comprehensively evaluated based on multiple dimensions such as processor load, memory utilization, and energy consumption. For example, for execution unit A to process task 1, it may consume 75% of CPU resources, 60% of memory resources, and consume 3.5W of energy, resulting in a weighted resource consumption score of 0.68; while execution unit B, when processing the same task, consumes 60% of CPU resources, 80% of memory resources, and consumes 2.8W of energy, resulting in a resource consumption score of 0.72.

[0109] The bidding function outputs the bidding value based on the current state of the execution unit and the characteristics of the task. The bidding value reflects the execution unit's willingness to process the task. For example, execution unit A has a low current load and a bidding value of 0.85 for task 1; execution unit B has a medium current load and a bidding value of 0.65 for task 1.

[0110] The matching degree is calculated by comparing the relationship between resource consumption score and competition value. One approach is to calculate the cosine similarity between the two, and another is to calculate their weighted average. For example, for execution unit A processing task 1, the resource consumption score is 0.68 and the competition value is 0.85. With weights of 0.4 and 0.6 respectively, the weighted average is 0.782. For execution unit B processing task 1, the resource consumption score is 0.72 and the competition value is 0.65, resulting in a weighted average of 0.678. These weighted averages are normalized to convert into preliminary task assignment probabilities; for example, the probability of execution unit A processing task 1 is 0.536, and the probability of execution unit B processing task 1 is 0.464.

[0111] When considering inter-task dependencies, the initial task allocation probabilities are adjusted. If dependent tasks are assigned to different execution units, the communication overhead between these units must be considered. Communication overhead can be quantified using factors such as network bandwidth and communication latency. For example, if the communication overhead between execution unit A and execution unit B is 0.25 (normalized value), when task 1 is assigned to execution unit A and its dependent task 2 is assigned to execution unit B, the task allocation probability is penalized based on the communication overhead. Specifically, the probability of task 1 being assigned to execution unit A can be reduced from 0.536 to 0.536 × (1 - 0.25) = 0.402.

[0112] Conversely, if dependent tasks are assigned to the same execution unit, the system rewards them based on their parallelism, increasing the probability of task assignment. Task parallelism can be obtained by analyzing the internal structure of the tasks or historical execution data. For example, if tasks 1 and 2 can be executed in partial parallelism on the same execution unit with a parallelism of 0.3 (normalized value), then the probability of assigning both tasks 1 and 2 to execution unit A will increase from the original value to the original value × (1 + 0.3).

[0113] Through multiple rounds of iterative calculations, the target execution unit for each task is ultimately determined. For example, in a system containing 5 tasks and 3 execution units, the final task allocation scheme could be: Task 1 and Task 2 are assigned to execution unit A, Task 3 is assigned to execution unit B, and Task 4 and Task 5 are assigned to execution unit C. Simultaneously, the execution order and resource allocation information of the tasks are recorded, such as allocating 70% of the processor resources to execution unit A for Task 1 and 30% of the processor resources to execution unit A for Task 2, and Task 1 must be executed before Task 2.

[0114] In practical applications, this method can adaptively adjust the task allocation scheme based on dynamic changes. For example, when the load on an execution unit suddenly increases, its competitive value decreases accordingly, leading to a lower probability of task allocation and thus distributing the task to other more suitable execution units. This dynamic adjustment mechanism ensures efficient utilization of system resources and timely task processing.

[0115] Actual testing shows that in a large system containing 50 tasks and 10 execution units, using this method for task allocation improves the overall system throughput by 23%, reduces the average task response time by 18%, and increases resource utilization by 15% compared to the traditional static allocation method, thus verifying the effectiveness and practical value of the method.

[0116] This invention relates to a knowledge graph-based virtual workplace task automatic generation and allocation system, comprising:

[0117] The first unit is used to acquire task information in the virtual workplace and construct a multi-level workplace knowledge graph including a task layer and a role layer. The task layer contains task type nodes and prerequisite dependencies between tasks, while the role layer contains execution role nodes and role collaboration relationships.

[0118] The second unit is used to convert the task information into word vectors based on the multi-level workplace knowledge graph, construct a k-nearest neighbor graph structure based on the word vectors, perform local information diffusion on the word vectors through random walks to generate task semantic features; recursively decompose the task semantic features to decompose the overall task objective into multiple sub-objectives, combine the sub-objectives based on the dependency relationships in the multi-level workplace knowledge graph, decompose the time complexity and resource dependency relationships of each sub-task in the decomposition tree, and generate a task decomposition graph.

[0119] The third unit is used to obtain historical task data of candidate executors from the virtual workplace task execution system, construct a capability profile of the candidate executors, and regard the candidate executors as execution units with autonomous decision-making capabilities based on the capability profile. Through task negotiation and bidding between execution units, combined with the dependency constraints of the task decomposition graph, a task allocation scheme is generated, and the allocation scheme is dynamically adjusted according to the execution status during the task execution process.

[0120] A third aspect of the present invention provides an electronic device, comprising:

[0121] processor;

[0122] Memory used to store processor-executable instructions;

[0123] The processor is configured to invoke instructions stored in the memory to execute the aforementioned method.

[0124] A fourth aspect of the present invention provides a computer-readable storage medium having stored thereon computer program instructions that, when executed by a processor, implement the aforementioned method.

[0125] This invention can be a method, apparatus, system, and / or computer program product. The computer program product may include a computer-readable storage medium having computer-readable program instructions loaded thereon for performing various aspects of the invention.

[0126] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some or all of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of the present invention.

Claims

1. A method for automatic generation and allocation of virtual workplace tasks based on knowledge graphs, characterized in that, include: Obtain task information in the virtual workplace and construct a multi-level workplace knowledge graph including a task layer and a role layer. The task layer contains task type nodes and prerequisite dependencies between tasks, while the role layer contains execution role nodes and role collaboration relationships. Based on the multi-level workplace knowledge graph, the task information is converted into word vectors, and a k-nearest neighbor graph structure is constructed based on the word vectors. Local information diffusion of word vectors is performed through random walk to generate task semantic features. The semantic features of the task are recursively decomposed into multiple sub-objectives based on the overall task objective. Based on the dependency relationships in a multi-level workplace knowledge graph, sub-goals are combined, the time complexity and resource dependencies of each sub-task are decomposed, and a task decomposition graph is generated, including: Based on the dependencies, the sub-targets are analyzed for correlation. Sub-targets with correlation higher than a preset correlation threshold are combined to form multiple sub-target combination sets. The execution cost of each sub-target is calculated based on the expected execution time and resource consumption of each sub-target in the sub-target combination set. The sub-target combination with the lowest execution cost and meeting the preset dependency strength requirement is selected as the optimal combination scheme. For the sub-objectives in the optimal combination scheme, obtain the task input size and single operation time, determine the fixed overhead time during task execution, and calculate the time complexity of each sub-objective based on the input size, the single operation time and the fixed overhead time; Based on the time complexity, a dependency matrix of tasks and resources is constructed. The dependency matrix records the degree of dependence of each task on various types of resources. A task decomposition graph is generated based on the dependency matrix. Historical task data of candidate executors are obtained from the virtual workplace task execution system to construct a capability profile of the candidate executors. Based on the capability profile, the candidate executors are regarded as execution units with autonomous decision-making capabilities. Through task negotiation and bidding between execution units, combined with the dependency constraints of the task decomposition graph, a task allocation scheme is generated, and the allocation scheme is dynamically adjusted according to the execution status during the task execution process.

2. The method according to claim 1, characterized in that, Constructing a multi-level workplace knowledge graph that includes task and role layers includes: The task layer includes a set of task type nodes and a set of task dependency edges. The role layer includes a set of execution role nodes and a set of role collaboration edges. Each edge in the task dependency edge set connects to an associated task type node, and each edge in the role collaboration edge set connects to an execution role node with a collaboration relationship. The collaboration intensity weight of each edge in the set of role collaboration relationships is calculated based on historical data of role collaboration. The collaboration intensity weight is obtained by weighting the normalized value of the number of collaborations and the normalized value of the collaboration effect score. The collaboration effect score is based on the completion quality assessment of historical collaboration tasks. The task attribute features and role attribute features are transformed into vectors respectively. The correlation between the transformed feature vectors is calculated to obtain the node pair correlation, which represents the degree of association between the task type node and the execution role node.

3. The method according to claim 1, characterized in that, Based on the multi-level workplace knowledge graph, the task information is converted into word vectors. A k-nearest neighbor graph structure is constructed based on these word vectors. Local information diffusion is performed on the word vectors using a random walk approach to generate task semantic features, including: Convert the word sequence in the task description text of the task information into a word vector; The semantic mutual information between word vectors is calculated. The semantic mutual information is obtained by feature transformation of word vectors and interaction matrix. Based on the semantic mutual information, a k nearest neighbor graph structure is constructed. The connection relationship between each word vector and its k most similar nodes is retained. The retained connection relationship is assigned a decay weight. The decay weight is obtained by distance weighting the semantic mutual information using Gaussian kernel function. Multi-hop feature propagation is performed based on decaying weights of connectivity relationships, and local information diffusion is carried out on word vectors through random walks to generate task semantic features.

4. The method according to claim 1, characterized in that, Based on the capability profile, candidate executors are treated as execution units with autonomous decision-making capabilities. Through task negotiation and bidding among execution units, combined with the dependency constraints of the task decomposition graph, a task allocation scheme is generated, including: Construct a state vector for the execution unit, which includes a profile vector corresponding to the capability profile and a load level index. Calculate the utility value of the execution unit for the task based on the matching degree between the profile vector and the task requirements and the load level index. The bidding function of the execution unit is constructed based on the utility value. The bidding function is calculated by multiplying the utility value by the exponential decay term of the execution cost. The execution cost includes a weighted combination of time delay cost and load transfer cost. The current load status and remaining resource amount of the execution unit are normalized and then weighted and summed to obtain the resource consumption score. The resource consumption score is matched with the bid value output by the bidding function to obtain the task allocation probability. Combined with the dependency constraints of the task decomposition graph, a task allocation scheme is generated.

5. The method according to claim 4, characterized in that, The task allocation probability is obtained by matching the resource consumption score with the bid value output by the bidding function. Combined with the dependency constraints of the task decomposition graph, a task allocation scheme is generated, including: When multiple tasks with dependencies are assigned to different execution units, the task assignment probability is penalized based on the communication overhead between execution units, thus reducing the task assignment probability; when multiple tasks with dependencies are assigned to the same execution unit, the task assignment probability is rewarded based on the parallelism of the tasks, thus increasing the task assignment probability. A task allocation scheme is generated based on the adjusted task allocation probability. The task allocation scheme determines the target execution unit for each task and records the execution order and resource allocation information of the tasks.

6. A knowledge graph-based virtual workplace task automatic generation and allocation system, used to implement the method as described in any one of claims 1-5, characterized in that, include: The first unit is used to acquire task information in the virtual workplace and construct a multi-level workplace knowledge graph including a task layer and a role layer. The task layer contains task type nodes and prerequisite dependencies between tasks, while the role layer contains execution role nodes and role collaboration relationships. The second unit is used to convert the task information into word vectors based on the multi-level workplace knowledge graph, construct a k-nearest neighbor graph structure based on the word vectors, and perform local information diffusion on the word vectors through random walk to generate task semantic features. The semantic features of the task are recursively decomposed, the overall task objective is decomposed into multiple sub-objectives, the sub-objectives are combined based on the dependency relationships in the multi-level workplace knowledge graph, the time complexity and resource dependency relationships of each sub-task are decomposed, and a task decomposition graph is generated. The third unit is used to obtain historical task data of candidate executors from the virtual workplace task execution system, construct the capability profile of the candidate executors, and regard the candidate executors as execution units with autonomous decision-making capabilities based on the capability profile. Through task negotiation and bidding between execution units, combined with the dependency constraints of the task decomposition graph, a task allocation scheme is generated, and the allocation scheme is dynamically adjusted according to the execution status during the task execution process.

7. An electronic device, characterized in that, include: processor; Memory used to store processor-executable instructions; The processor is configured to invoke instructions stored in the memory to execute the method according to any one of claims 1 to 5.

8. A computer-readable storage medium having computer program instructions stored thereon, characterized in that, When the computer program instructions are executed by the processor, they implement the method described in any one of claims 1 to 5.

Images