Method, apparatus, device, and product for allocating code tasks

Abstract

Embodiments of the present disclosure relate to methods, apparatuses, devices, and products for allocating code tasks. The method includes determining a data basis for the submission history information based on the submission history information of the code tasks, where the submission history information includes task information, personnel information, and personnel skill information. The method includes determining, by a target model, a knowledge graph associated with personnel, skills, and code tasks based on the determined data basis, where the target model is configured with a time decay model and an attention mechanism. The method includes determining, by the target model, a set of personnel matching each code task based on each code task and the knowledge graph. The method further includes, in response to a code task going wrong, allocating the code task to a person matching the code task by the target model based on the comprehensive score of each person in the set of personnel, where the comprehensive score is determined based on the knowledge graph and the time decay coefficient of each person.

Description

Technical Field

[0001] This application relates to the field of computer technology, and more particularly to a method, apparatus, electronic device, and computer program product for allocating code tasks. Background Art

[0002] Large-scale software development generally refers to software development projects with large scale, high complexity, and involving multiple functional modules and subsystems. These projects may require a development team of dozens or even hundreds of people and take months or years to complete. With the development of Internet technology, the field of software development has also seen progress and innovation. Nowadays, the software development mode is no longer limited to the traditional centralized collaboration, that is, the way that everyone must develop together at the same location. Instead, it has crossed geographical boundaries and realized the widespread practice of remote development. Summary of the Invention

[0003] Embodiments of the present disclosure provide a method, apparatus, electronic device, and computer program product for allocating code tasks.

[0004] According to a first aspect of the present disclosure, a method for allocating code tasks is provided. The method includes determining a data basis for the submission history information based on the submission history information of the code tasks, where the submission history information includes task information, personnel information, and personnel skill information, and the data basis includes at least one of the ownership portrait of each code task and the modification behavior pattern for each code task. The method includes determining, by a target model, a knowledge graph associated with personnel, skills, and code tasks based on the determined data basis, where the target model is configured with a time decay model and an attention mechanism, and the knowledge graph includes the skills, workload, collaboration relationships, and current status of the personnel. The method includes determining, by the target model, a set of personnel matching each code task based on each code task and the knowledge graph. In addition, the method further includes, in response to a code task error, allocating the code task to a person matching the code task by the target model based on the comprehensive score of each person in the set of personnel, where the comprehensive score is determined based on the knowledge graph and the time decay coefficient of each person.

[0005] According to a second aspect of the present disclosure, there is provided an apparatus for allocating code tasks. The apparatus includes a data basis determination module configured to determine a data basis for the submission history information based on the submission history information of the code tasks, where the submission history information includes task information, personnel information, and personnel skill information, and the data basis includes at least one of an ownership profile of each code task and a modification behavior pattern for each code task. The apparatus includes a knowledge graph determination module configured to determine a knowledge graph associated with personnel, skills, and code tasks by a target model based on the determined data basis, where the target model is configured with a time decay model and an attention mechanism, and the knowledge graph includes the skills, workload, collaboration relationships, and current status of the personnel. The apparatus includes a personnel set determination module configured to determine a set of personnel matching each code task by the target model based on each code task and the knowledge graph. In addition, the apparatus further includes a personnel allocation module configured to, in response to a code task error, allocate the code task to a personnel matching the code task by the target model based on the comprehensive scores of each personnel in the personnel set, where the comprehensive scores are determined based on the knowledge graph and the time decay coefficient of each personnel.

[0006] According to a third aspect of the present disclosure, there is provided an electronic device. The electronic device includes a processor and a memory coupled to the processor, where the memory has instructions stored therein, and the instructions, when executed by the processor, cause the electronic device to execute the method according to the first aspect.

[0007] In a fourth aspect of the present disclosure, there is provided a computer program product. The computer program product is tangibly stored on a non-transitory computer-readable medium and includes computer-executable instructions that, when executed, cause a computer to perform the steps of the method according to the first aspect of the present disclosure.

[0008] The Summary section is intended to introduce a selection of concepts in a simplified form, which will be further described in the Detailed Description below. The Summary section is not intended to identify key features or main features of the claimed subject matter, nor is it intended to limit the scope of the claimed subject matter. BRIEF DESCRIPTION OF THE DRAWINGS

[0009] In conjunction with the accompanying drawings and with reference to the following detailed description, the above and other features, advantages, and aspects of the embodiments of the present disclosure will become more apparent. In the drawings, the same or similar reference numerals denote the same or similar elements, where:

[0010] Figure 1 A schematic diagram showing an example environment in which the devices and / or methods according to the embodiments of the present disclosure may be implemented;

[0011] Figure 2The flowchart of a method for allocating code tasks according to an embodiment of the present disclosure is shown;

[0012] Figure 3 The schematic diagram of an example step for allocating code tasks according to an embodiment of the present disclosure is shown;

[0013] Figure 4A The schematic diagram of an example data foundation construction for allocating code tasks according to an embodiment of the present disclosure is shown;

[0014] Figure 4B The schematic diagram of the collaboration intensity for allocating code tasks according to an embodiment of the present disclosure is shown;

[0015] Figure 5A The schematic diagram of a developer skill knowledge graph based on a large model according to an embodiment of the present disclosure is shown;

[0016] Figure 5B The schematic diagram of an example of a developer skill knowledge graph according to an embodiment of the present disclosure is shown;

[0017] Figure 6 The schematic diagram of dynamic state perception based on a large model according to an embodiment of the present disclosure is shown;

[0018] Figure 7 The schematic diagram of the temporal attention mechanism of a target model according to an embodiment of the present disclosure is shown;

[0019] Figure 8 The schematic diagram of intelligent allocation and dynamic adjustment of model-based code tasks according to an embodiment of the present disclosure is shown;

[0020] Figure 9 The block diagram of a device for allocating code tasks according to some embodiments of the present disclosure is shown; and

[0021] Figure 10 The block diagram of an electronic device according to an embodiment of the present disclosure is shown.

[0022] In all the drawings, the same or similar reference numerals denote the same or similar elements. Detailed Description of the Embodiment

[0023] It can be understood that before using the technical solutions disclosed in the embodiments of the present disclosure, the types, usage scopes, usage scenarios, etc. of the personal information (such as voice) involved in the present disclosure should be informed to the user and the user's authorization should be obtained in an appropriate manner in accordance with relevant laws and regulations.

[0024] Embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. Although some embodiments of the present disclosure are shown in the drawings, it should be understood that the present disclosure can be implemented in various forms and should not be construed as limited to the embodiments set forth herein. Instead, these embodiments are provided to more thoroughly and completely understand the present disclosure. It should be understood that the drawings and embodiments of the present disclosure are only for exemplary purposes and are not used to limit the protection scope of the present disclosure.

[0025] In the description of the embodiments of the present disclosure, the term "including" and its similar terms should be understood as open inclusion, that is, "including but not limited to". The term "based on" should be understood as "at least partially based on". The term "one embodiment" or "the embodiment" should be understood as "at least one embodiment". The terms "first", "second", etc. may refer to different or the same objects, unless otherwise specified. There may also be other explicit and implicit definitions hereinafter.

[0026] As mentioned above, large-scale software development projects are large in scale, and many difficulties will naturally be encountered during the development process. One of them is the code error alarm and the processing work after the code error alarm, including which developers are assigned to handle it and how to allocate it. In the related art, a method of allocating the alarmed code tasks based on specified rules is adopted. This method cannot adapt to the dynamic changes of the team and also ignores the professional expertise and real-time status of the developers. There is another technology that allocates the alarmed code tasks based on the last modifier of the alarmed code tasks. This solution does not take into account the collaboration history of the code task developers and the current status of the developers, and is likely to cause uneven allocation of the alarmed code tasks. In practice, a mode that relies on the team leader to manually allocate tasks based on personal experience is also adopted. This mode has low efficiency, especially in the development environment of large teams, and it is difficult to be applied on a large scale.

[0027] To this end, an embodiment of the present disclosure proposes a scheme for automatically assigning code tasks to users. First, based on the submission history information of the code task, the data basis for the submission history information is determined, wherein the submission history information includes task information, personnel information and personnel skill information, and the determined data basis includes the ownership portrait of each code task, and at least one of the modification behavior patterns for each code task. Afterwards, a knowledge graph associated with personnel, skills and code tasks is constructed based on the above-determined data basis using a target model. The target model is configured with a time decay model and an attention mechanism, and the constructed knowledge graph includes information on personnel skills, workload, collaborative relationships and current status. Then, the target model determines the set of personnel matching each code task based on the specific circumstances of each code task and the constructed knowledge graph. Finally, when a code task goes wrong, the target model can assign the code task to the personnel matching the code task based on the comprehensive score of each person in the personnel set. Among them, the comprehensive score is determined based on the knowledge graph and the time decay coefficient of each person.

[0028] Therefore, according to the scheme of the embodiment of the present disclosure, with the help of the model capabilities of the target model, it is possible to achieve in-depth technical understanding and real-time and accurate drawing of capability portraits, so that when a code task fails, the erroneous code task can be dynamically and efficiently allocated to relevant personnel according to the current status of the relevant personnel to achieve maintenance of the code task, ensuring the reliability and timeliness of the processing of the erroneous code task, thereby improving the user experience.

[0029] The embodiments of the present disclosure will be described in detail below in conjunction with the accompanying drawings. Figure 1 A schematic diagram of an example environment 100 is shown in which devices and / or methods according to embodiments of the present disclosure may be implemented.

[0030] In order to dynamically handle the alarm or error of the code task, the personnel responsible for error alarm processing can be assigned to the erroneous code task in a targeted manner according to the submission history information of the code task. In some embodiments, the data basis for the submission history information can be determined according to the submission history information of the code task, and then the knowledge graph 130 associated with the personnel, skills and code task can be determined based on the data basis. Figure 1 As shown, in some embodiments, a knowledge graph 130 can be constructed based on personnel information 110 and task information 120. The personnel information 110 includes personnel skill information. In this article, personnel are also referred to as developers or developers.

[0031] In some embodiments, the submission history information includes task information, personnel information, and the skill information of the personnel. The task information refers to information related to code tasks, such as code changes, submission frequency, and other information. The personnel information indicates information such as the degree of participation of developers in different types of code tasks. The skill information of the personnel refers to information such as the expertise areas of the developers.

[0032] In some embodiments, the constructed data foundation includes at least one of the ownership portrait of each code task and the modification behavior pattern for each code task. In some embodiments, an accurate ownership portrait for each code task can be established by scanning all historical commit records of a version control system (such as Git). By establishing the ownership portrait, the primary responsible person and the secondary responsible person can be represented for each code task.

[0033] In some embodiments, after the ownership portrait of the code task is established, based on this, the modification behavior pattern of the developer can be further analyzed. By analyzing the modification behavior pattern, a skill feature portrait of the developer can be established, so as to provide a decision-making basis for the intelligent allocation of subsequent code tasks.

[0034] In some embodiments, the constructed data foundation may also include the complete collaboration network obtained by integrating the foregoing ownership portrait and modification behavior model, that is, the collaboration relationship graph, so that the core developers and domain experts of the team can be identified from the collaboration relationship graph. Through the construction of such a progressive data foundation, a dynamically updated knowledge base can be formed, so as to provide reliable data support for the allocation decision of subsequent alarm code tasks, ensure that the alarm code task can be assigned to the most suitable processing personnel, improve the development efficiency of the entire development team, and enhance the user experience.

[0035] After the data foundation for supporting subsequent task decision-making and allocation is constructed, the model capabilities of the target model 140 can be introduced to construct a developer skill knowledge graph with model awareness on this basis, which can facilitate a more fine-grained and more suitable allocation of alarm or error-prone code tasks to target developers in the subsequent task allocation decision-making process.

[0036] Reference Figure 1, in some embodiments, the target model 140 can be used to construct an indication map 130 associated with personnel, skills, and code tasks based on a previously determined data foundation, which can achieve a deeper technical understanding and a more accurate ability profile. The target model 140 can be a large-scale pre-trained model, which is an artificial intelligence model based on deep learning technology. In some embodiments, the target model 140 can be a model configured with a temporal attention mechanism, that is, it can be configured with a time decay model and an attention mechanism. With the temporal attention mechanism, it is possible to ensure that the decision-making for the allocation of subsequent alarm code tasks adapts to the dynamic changes in the collaboration relationship.

[0037] In some embodiments, the constructed knowledge map 130 includes the skills, workload, collaboration relationship, and current status of personnel. In some embodiments, the target model 140 can also be used to continuously analyze the constructed knowledge map 130 to achieve dynamic updates of the constructed knowledge map 130.

[0038] As Figure 1 shown, in some embodiments, based on the knowledge map 130 and the model-based allocation system 140, it is possible to achieve in-depth mining of the submission history information and dynamic perception of the real-time status of personnel to obtain an allocation result 150, that is, to assign code tasks to relevant personnel. Especially in the case of an alarm for an error in a code task, the relevant alarm code task can be assigned to relevant personnel for subsequent processing.

[0039] In some embodiments, the target model can use the knowledge map and, based on the code task, determine a matching set of personnel for each code task. For example, if code task 1 is jointly developed by personnel A and personnel B, then personnel A and personnel B can be the personnel in the matching set of personnel for code task 1.

[0040] In some embodiments, when a code task goes wrong, the target model can determine the most suitable person to perfect the faulty code task based on the comprehensive scores of each person in the matching set of personnel. In some embodiments, the comprehensive score can be determined based on the knowledge map and the time decay coefficient of each person. For example, when code task 1 goes wrong and personnel A is currently in an unresponsive state and the decay coefficient of personnel A relative to personnel B is smaller, then the comprehensive score of personnel B is higher. Therefore, in the absence of other factors, the faulty code task 1 can be assigned to personnel B.

[0041] Thus, according to the solution of the embodiments of the present disclosure, by virtue of the capabilities of the target model, in-depth technical understanding and real-time and accurate ability profiling can be achieved. Thus, when code alarms occur, the alarm code tasks can be efficiently assigned to relevant personnel dynamically according to the current status of relevant personnel, ensuring the reliability and timeliness of the processing of the alarm code tasks, thereby enhancing the user experience.

[0042] It should be understood that the architectures and functions in the example environment 100 are described only for exemplary purposes and do not imply any limitation on the scope of the present disclosure. Embodiments of the present disclosure can also be applied to other environments with different structures and / or functions.

[0043] The following will be combined with Figures 2 to 10 The process according to the embodiments of the present disclosure will be described in detail. For ease of understanding, the specific data mentioned in the following description are all exemplary and do not limit the protection scope of the present disclosure. It can be understood that the embodiments described below may also include additional actions not shown and / or actions shown may be omitted, and the scope of the present disclosure is not limited in this regard.

[0044] Figure 2 A flowchart of a method 200 for assigning code tasks according to an embodiment of the present disclosure is shown. Next, taking the device for assigning code tasks as the execution subject as an example, the method 200 will be schematically described. The method 200 includes block 202, block 204, block 206, and block 208.

[0045] At block 202, based on the submission history information of the code task, a data basis for the submission history information can be determined. The submission history information includes task information, personnel information, and personnel skill information. The data basis includes at least one of the ownership profile of each code task and the modification behavior pattern for each code task. To dynamically handle the alarm situation of code tasks, the alarm handling personnel for the error-prone code tasks can be assigned specifically according to the submission history information of the code tasks. In some embodiments, the data basis for the submission history information can be determined according to the submission history information of the code task, and then based on this data basis, the knowledge graph 130 associated with personnel, skills, and code tasks can be determined. As Figure 1As shown, in some embodiments, a knowledge graph 130 can be constructed based on the personnel information 110 and the task information 120. Among them, the personnel information 110 includes the skill information of the personnel. In some embodiments, the submission history information includes task information, personnel information, and the skill information of the personnel. The task information refers to information related to code tasks, such as code changes, submission frequencies, and other information. The personnel information indicates information such as the degree of participation of developers in different types of code tasks. The skill information of the personnel refers to information such as the expertise fields of the developers. In some embodiments, the constructed data basis includes at least one of the ownership portrait of each code task and the modification behavior pattern for each code task. By establishing the ownership portrait, the primary responsible person and the secondary responsible person can be represented for each code task. In some embodiments, after the ownership portrait of the code task is established, on this basis, the modification behavior pattern of the developer can be further analyzed. With the analysis of the modification behavior pattern, a skill feature portrait of the developer can be established, so as to provide a decision-making basis for the intelligent allocation of subsequent code tasks.

[0046] At block 204, the target model can determine a knowledge graph associated with personnel, skills, and code tasks based on the determined data basis. The target model is configured with a time decay model and an attention mechanism. The knowledge graph includes the skills, workload, collaboration relationships, and current status of the personnel. When the data basis for supporting subsequent task decision-making and allocation is constructed, the model capabilities of the target model 140 can be introduced to construct, on this basis, a developer skill knowledge graph with model awareness, which can facilitate the allocation of more fine-grained and more suitable alarm code tasks for the target developers in the subsequent task allocation decision-making process. Refer to Figure 1 , in some embodiments, the target model 140 can be used to construct an indication graph 130 associated with personnel, skills, and code tasks based on the previously determined data basis, so as to achieve a deeper technical understanding and a more accurate ability portrait. The target model 140 can be a large-scale pre-trained model, which is an artificial intelligence model based on deep learning technology. In some embodiments, the target model 140 can be a model configured with a temporal attention mechanism, that is, it can be configured with a time decay model and an attention mechanism. With the temporal attention mechanism, it can be ensured that the decision-making for the subsequent allocation of alarm code tasks adapts to the dynamic changes of the collaboration relationships. In some embodiments, the constructed knowledge graph 130 includes the skills, workload, collaboration relationships, and current status of the personnel. In some embodiments, the target model 140 can also be used to continuously analyze the constructed knowledge graph 130 to achieve the dynamic update of the constructed knowledge graph 130.

[0047] At block 206, the target model can determine a set of personnel matching each code task based on each code task and the knowledge graph. As Figure 1 shown, in some embodiments, based on the knowledge graph 130 and the model-based assignment system 140, in-depth mining of the submission history information and dynamic perception of the real-time status of personnel can be achieved to obtain the assignment result 150, that is, assign the code task to the relevant personnel. For example, if code task 1 is jointly developed by personnel A and personnel B, then personnel A and personnel B can be the personnel in the set of personnel matching code task 1.

[0048] At block 208, in response to a code task error, the target model can assign the code task to the personnel matching the code task based on the comprehensive score of each person in the set of personnel, and the comprehensive score is determined based on the knowledge graph and the time decay coefficient of each person. In some embodiments, when a code task error occurs, the target model can determine the person most suitable for perfecting the error-prone code task according to the comprehensive score of each person in the matching set of personnel. For example, when code task 1 has an error and personnel A is currently in an unresponsive state and the decay coefficient of personnel A relative to personnel B is still small, so the comprehensive score of personnel B is higher, then the error-prone code task 1 can be assigned to personnel B.

[0049] Thus, according to the solution of the embodiments of the present disclosure, by virtue of the capabilities of the target model, in-depth technical understanding and real-time and accurate ability profiling can be achieved, so that when a code error alarm occurs, the error-prone code task of the error alarm can be efficiently assigned to the relevant personnel according to the current status of the relevant personnel, ensuring the reliability and timeliness of the processing of the error-prone code task of the error alarm, thereby improving the user experience.

[0050] Figure 3 shows a schematic diagram of an example step 300 for assigning code tasks according to an embodiment of the present disclosure. To dynamically handle the alarm situation of code tasks, the personnel for handling the error alarm of the error-prone code task can be assigned specifically according to the submission history information of the code task. And for the convenience of using data in the subsequent assignment decision-making process, the cornerstone for the assignment of the alarm code task can be laid first, that is, a basic data structure is constructed. As Figure 3 shown, at 310, a basic data structure can be constructed. In some embodiments, constructing the basic data structure can be further divided into three progressive levels to build a comprehensive developer-code association network.

[0051] The following will be combined with Figure 4A to describe. Figure 4A shows a schematic diagram of an example data basis construction 400A for assigning code tasks according to an embodiment of the present disclosure. Refer toFigure 4A , the data foundation construction 310 includes code ownership definition 410, modification behavior analysis 420, and collaboration relationship construction 430. These three steps are progressive. In some embodiments, the ownership relationship of code tasks or code modules can be analyzed by scanning all historical commit records of a version control system (such as Git).

[0052] In some embodiments, the code ownership definition 410 further includes analyzing commit records, introducing a time decay model, and identifying responsible persons. In some embodiments, at 411, analyze the commit records. That is, the contribution degree of each developer or personnel to the code task or code module can be calculated by analyzing quantitative metrics such as the frequency of commit records of the code task or code module, and the change amount of the code lines of each code task or code module. Through such contribution degree calculation, the contribution degree of each developer or personnel in each code task or code module can be quantified, so that the contribution degree can be referred to for task allocation in the subsequent decision-making process.

[0053] In some embodiments, at 412, introduce a time decay model to ensure that recently modified code tasks can obtain higher weights. In some embodiments, at 413, identify responsible persons. That is, identify the primary responsible person and the secondary responsible person for each code task or code module, which can lay a foundation for determining the matching set of personnel in the future. Through the operations at 411, 412, and 413, an accurate ownership profile can be established for each code task or code module.

[0054] In some embodiments, the calculation formula for the contribution degree is as follows:

[0055]

[0056] where N is the total number of commit records of the developer in the code task or code module; is the weight of the modification type; is the number of modified code lines in the i-th commit; is the time decay weight; is the collaboration weight.

[0057] In some embodiments, the calculation formula for the time decay weight is as follows:

[0058]

[0059] where is the time difference (in days) between the current time and the i-th commit time, is the decay time coefficient, which is used to adjust the speed of time decay.

[0060] In some embodiments, the calculation formula for the collaboration weight is as follows:

[0061]

[0062] where is the collaboration weight coefficient, which is used to adjust the influence degree of the collaboration frequency on the collaboration weight.

[0063] After the code ownership in the data foundation is defined, the next level of the data foundation is the modification behavior analysis 420. In some embodiments, the modification behavior analysis 420 includes semantic analysis of the submitted information and establishing a skill feature profile.

[0064] Referring to Figure 4A , in some embodiments, at 421, semantic analysis of the submitted information, that is, semantic analysis of the submission history information of the code task or code module to identify different types of code changes, such as function development, defect repair, and code refactoring. In some embodiments, the difference (diff) information provided by the version control system can be used, and by analyzing operations such as addition, deletion, and modification of the code, the type of code change can be initially determined. For example, when a line marked with a "+" is detected, it can be determined that the change type corresponding to this line of code may be a newly added function, class, or module, etc., corresponding to function development or new feature addition. Another example is that when a line marked with a "-" is detected, it can be determined that the change type corresponding to this line of code may be removing obsolete code or abandoned functions, corresponding to code cleaning or technical debt repayment. Another example is that when a line with both "+" and "-" is detected, it can be determined that the change type corresponding to this code may be performance optimization or logic adjustment, corresponding to defect repair or code refactoring.

[0065] In some embodiments, the change scope of the code task or code module can also be analyzed. For example, at the file level, the change type can be determined as a front-end, back-end, or configuration file change according to the type of the file. Another example is that at the module or task level, the attribute ownership of the changed module or task can be determined by combining the directory structure of the code module or code task. Another example is that at the function or class level, a static code analysis tool (such as an AST parser) can be used to extract the functions or classes involved in the change to further refine the change scope.

[0066] In some embodiments, for database-related code, the type of code change can be determined by analyzing the corresponding SQL statements or API calls for addition, deletion, query, and modification operations. For example, the newly added or deleted API calls in the code task or code module can be detected to determine whether there is a change in external dependencies. Another example is that the modification of configuration files (such as.yaml,.json) can also be detected to determine whether there is an environmental configuration or parameter adjustment, etc.

[0067] In some embodiments, natural language processing (NLP) techniques can also be used to further extract the semantic information of the changes. For example, a word segmentation tool can be used to segment the submitted historical information to extract key verbs and nouns, and combined with the context to determine the type of change. For example, "fix" corresponds to defect repair, "add" corresponds to feature development, and "refactor" corresponds to code refactoring. In some embodiments, pre-trained language models (such as BERT, GPT) can also be used to perform semantic classification on the submitted historical information. In some embodiments, the submitted historical information and the code change content can also be combined for context semantic analysis. For example, according to the submitted information "Add user authentication" and the newly added auth module in the code change, it can be determined as feature development. According to the submitted information "Refactor database connection logic" and combined with the modification of the database connection code in the code change, it can be determined as code refactoring. Alternatively, large models and prompts can also be used to directly analyze the semantics of code changes and submitted information to quickly identify the type of change.

[0068] In some embodiments, the structured information of code changes and the unstructured semantic information of submitted information can also be combined to form a multi-modal analysis framework, and the add / delete / modify features of code changes and the semantic features of submitted information can be fused to construct a multi-dimensional feature vector. For example, if a function is newly added in the code change and the submitted information contains the keyword "Add", it can be further confirmed as feature development. In some embodiments, machine learning or deep learning models (such as random forest, LSTM, Transformer) can be used to classify the fused feature vector. For example, the input of the model can be the code change features and the submitted information features, so that the output of the model can be the type of change (such as feature development, defect repair, refactoring, etc.). In some embodiments, historical commit records can also be combined to analyze the change patterns of developers. For example, if a developer frequently submits "fix" type changes recently, it indicates that defect repair is the main focus at the current stage.

[0069] Reference Figure 4A , at 422, establish a skill feature profile. In some embodiments, the participation degree and expertise field of each developer or person in different types of tasks can be determined, and a skill feature profile can be established for each developer or person to provide a decision basis for subsequent intelligent allocation.

[0070] In some embodiments, the language processing capabilities of large models can be utilized to parse the resumes of each person or developer, and extract information such as skill keywords, project experience, and technology stacks from the resumes, in order to construct a preliminary skill profile for each person or developer, and label the programming languages, frameworks, tools, and domains (such as front-end, back-end, AI, etc.) they are proficient in.

[0071] In some embodiments, large models can also be used to analyze technical documents, design documents, code comments, etc. written by developers, in order to understand the technical expression ability and in-depth understanding of specific domains of each developer, identify the professionalism of developers in specific technical fields (such as algorithm optimization, system architecture design, etc.), and evaluate their technical depth.

[0072] In some embodiments, task assignment, completion records, comments, and collaboration data can also be extracted from project management tools (such as Jira, Trello, Asana), and combined with large models to analyze task types (such as feature development, defect repair, refactoring, etc.) and the participation frequency of each developer or person, in order to quantify the participation degree of developers in different task types, and label their experience values in specific task types.

[0073] In some embodiments, large models can also be used to analyze the commit records of code repositories (such as Git), and identify the types (such as feature development, Bug repair, performance optimization, etc.) and complexity of code changes, in order to construct the technical behavior patterns of developers, so that their contribution degrees and expertise areas in different task types can be labeled.

[0074] In some embodiments, the project management platform and code collaboration records can also be combined, and large models can be used to construct a collaboration network of developers to analyze their roles in the team (such as core developers, technical experts, support roles, etc.), in order to identify the technical influence and collaboration ability of developers in the team, so as to further improve their skill profiles.

[0075] In some embodiments, the above information can also be integrated into the developer skill knowledge graph, and the skill tags and weights can be dynamically updated to reflect the real-time status and ability changes of developers, so as to form a multi-dimensional association graph of "developer - skill - task type", which can provide accurate basis for task assignment and team management.

[0076] As Figure 4A shown, after completing the first two steps of the data foundation construction, on the basis of the first two steps, the next level of the data foundation is the collaboration relationship construction 430. At 431, record the collaboration history, that is, record the collaboration history between developers, including the frequency and scope of jointly modifying the same module. The collaboration history record can be as shown in Table 1 below:

[0077]

[0078] Reference Figure 4A , at 432, construct a collaboration relationship graph. That is, construct a collaboration relationship graph with weights, where nodes represent developers or developers, and edges represent the collaboration relationships between developers or developers. In some embodiments, at 433, the collaboration intensity between each developer can also be quantified. Combine Figure 4B , Figure 4B shows a schematic diagram of the collaboration intensity 400B for allocating code tasks according to an embodiment of the present disclosure. As Figure 4B shown, a weighted collaboration relationship graph is constructed among Person A, Person B, Person C, and Person D, and the weight represents the collaboration relationship intensity between Person A and Person B. Among them, the collaboration weight of Person A for Person B is 0.85, while the collaboration weight of Person B for Person A is 0.65. Through the nodes representing persons, the edges representing collaboration relationships, and the weight values between the edges, the core developers and domain experts in the team can be identified.

[0079] In some embodiments, a rolling index can be used to construct the data foundation. The rolling index is mainly used in scenarios where the index needs to be updated frequently to ensure that stable services can still be provided during the update process. It achieves seamless switching and high availability by maintaining two or more index copies (such as index A and index B) and alternately using different copies when updating the index. For example, in the initial state, index A provides services and index B is in the standby state, then all query requests will be routed to index A. When the system needs to update the index, the update operation will be performed on the standby index B.

[0080] In some embodiments, the update process of index B includes rescan the commit records from the code repository, recalculate the association relationship between developers and code modules, and update the developer skill knowledge graph, etc. After the update of index B is completed, necessary verification can be performed to ensure that the data of index B is correct and complete. After the verification passes, the system will switch the service provider from index A to index B. After that, index B starts to provide services externally, and index A enters the standby state. At this time, all query requests of the system will now be routed to index B. When the next index update request arrives, the update operation will be performed on the standby index A. After the update is completed, the system will switch the service provider again, from index B back to index A.

[0081] By means of this method of rolling index switching, it is possible to ensure the regular update of the association relationship between developers or developers and code modules, ensuring the stability, integrity, and consistency of the constructed data foundation, thereby ensuring the accuracy of subsequent allocation decisions.

[0082] Figures 4A - 4B It describes a three - layer progressive data construction process, which can form a dynamically updated knowledge base to provide reliable data support for subsequent alarm assignment decisions, ensure that the most suitable handler can be found for each problem, thereby improving the problem - solving efficiency of the entire team and enhancing the user experience.

[0083] Return to Figure 3 , when at 310, after the basic data structure is constructed, at 320, a developer skill knowledge graph based on a large model can be constructed. The core goal of knowledge graph management is to accurately map the association relationship of "developer - skill - code module". By introducing the large - model ability, deeper technical understanding can be achieved and more accurate ability portraits can be depicted.

[0084] The following will be described in conjunction with Figure 5A as follows. Figure 5A FIG. shows a schematic diagram of a developer skill knowledge graph 500A based on a large model according to an embodiment of the present disclosure. Refer to Figure 5A , the developer skill knowledge graph 320 based on a large model includes code ability understanding 510, submission information interpretation 520, and skill graph update 530. That is, by deeply understanding the submission history records and relevant hints, a developer skill knowledge graph is generated. In some embodiments, the relevant information of the submission history records can be in the form of the previously constructed basic data with three progressive levels.

[0085] As Figure 5A shown, the code ability understanding 510 includes analyzing technical features, identifying programming patterns, and evaluating code quality. In some embodiments, at 511, analyze technical features is performed. That is, the submission history information of the code task can be analyzed with the help of a large model to achieve a deep technical understanding of the submission history information. For example, the large model can understand the technical features and complexity of the code in the submission history information. In some embodiments, at 512, identify programming patterns, and the programming patterns and technical preferences of each developer can also be identified with the help of the large model. In some embodiments, at 513, evaluate code quality, and the quality and technical depth of the code in the submission history records can be evaluated with the help of the large model.

[0086] Refer to Figure 5A , the submission information interpretation 520 includes extracting technical keywords, understanding technical paths, and identifying professional fields. In some embodiments, at 521, extract technical keywords is performed, that is, the technical keywords in the submission history information are analyzed with the help of a large model. At 522, understand technical paths is performed, that is, the technical paths for problem - solving are understood with the help of a large model. At 523, identify professional fields, that is, the professional fields of developers and the quality of solutions are identified with the help of a large model.

[0087] Continue to refer to Figure 5A The skill graph update 530 includes implementing updated skill tags, adjusting skill weights, and optimizing the picture structure. In some embodiments, at 531, implementing updated skill tags is performed, that is, leveraging a large model to update developers' skill tags in real time. In some embodiments, at 532, adjusting skill weights is performed, that is, performing adjustments to skill weights and professionalism scores. In some embodiments, at 533, optimizing the picture structure is performed, that is, optimizing the structural relationships of the knowledge graph.

[0088] In some embodiments, the input for the large model can be code submission records, context cues, and an external knowledge base (optional). Among them, the code submission records can include the submitted code content (code snippets, change content), submission information (commit message), including descriptive text, submission time, submitter information, and the code module path (such as file name, directory structure). The context cues can include project background information (such as the project's technology stack, target function), the function description of the code module, historical collaboration relationships (such as the collaboration frequency between developers), and task types (such as function development, defect repair, performance optimization, etc.). And the external knowledge base (optional) can include content such as the syntax rules of programming languages, the documentation of common technical frameworks and libraries, and industry standards and best practices.

[0089] In some embodiments, the output of the large model can be a knowledge graph including skill feature portraits, code module associations, and collaboration relationships. Among them, the skill feature portrait includes developers' skill tags (such as "Java back-end development", "front-end React", "database optimization"), skill weights (such as the proficiency score of a developer in a certain field), and areas of expertise (such as "performance optimization expert", "security vulnerability repair"). And the code module association can include the association relationship between the developer and the code module (such as the contribution degree of the developer to a certain module), and the technical characteristics of the module (such as "high-concurrency processing module", "data analysis module"). In addition, the collaboration relationship can include the collaboration intensity between developers (such as the frequency of jointly modifying the same module or task), and the role distribution within the team (such as "core developer", "code reviewer"). Combined Figure 5B , Figure 5B shows a schematic diagram of an example 500B of a developer skill knowledge graph according to an embodiment of the present disclosure. The knowledge graph is presented in the form of a graph structure, where nodes represent entities and edges represent the relationships between entities. For example, developer A is proficient in JAVA back-end development.

[0090] With the support of the large model, the system can better understand and manage the distribution of the team's technical capabilities, providing a more reliable decision-making basis for alarm allocation.

[0091] Return toFigure 3 After the basic data structure is built at 310 and the developer skill knowledge graph based on the large model is built at 320, dynamic state awareness based on the large model can be realized at 330. With the intelligent analysis ability of the large model, the dynamic state awareness module can accurately evaluate and predict the state of each person or developer, providing real-time decision support for alarm allocation.

[0092] The following will be described in conjunction with Figure 6 to describe. Figure 6 FIG. shows a schematic diagram of a dynamic state awareness 600 based on a large model according to an embodiment of the present disclosure. Referring to Figure 6 , the dynamic state awareness 330 based on the large model includes an intelligent load assessment 610, a time zone and state analysis 620, and a dynamic skill matching 630. That is, the real-time assessment of the development state of each developer or each person is mainly achieved through the above three core functions.

[0093] In some embodiments, the intelligent load assessment 610 includes understanding task complexity, evaluating cognitive burden, and predicting task risks, so as to analyze the current workload of the developer and determine whether he has enough time and energy to handle new alarm tasks. In some embodiments, at 611, the task complexity is understood, that is, the large model is used to analyze the tasks currently assigned to the developer and evaluate their technical difficulty and estimated completion time. In some embodiments, the current task description of the developer (such as code change content, task type) can be input into the large model, and then the large model can output a task complexity score (such as "high", "medium", "low"). For example, the input to the large model can be: the current task of developer A is "optimize the concurrency performance of the order management module", and the output of the large model can be: the task complexity score is "high".

[0094] In some embodiments, at 612, the cognitive burden is evaluated, that is, the large model is used to evaluate the cognitive burden of different types of tasks. For example, the large model can be used in combination with the task type (such as function development, defect repair) and the developer's skill specialty to evaluate the cognitive burden of the task on the developer. In some embodiments, at 613, the task risks are predicted, that is, the potential risks and completion time of the task are predicted. For example, the large model can be used to identify the priority of the developer's current task and determine whether a new alarm task can be inserted.

[0095] In some embodiments, the time zone and status analysis 620 includes analyzing calendars and records, understanding status information, and predicting contact times, so as to judge the availability of developers and ensure that developers are at work or responsive when alarms are assigned. In some embodiments, at 621, the analysis of calendars and records is performed, that is, by integrating information such as calendars and meeting records, to identify whether developers have free time to handle alarms. In some embodiments, at 622, the understanding of status information is performed, that is, by analyzing the status information (such as "online", "busy") of instant messaging tools (such as Slack, Teams) to judge the real-time status of developers. In some embodiments, at 623, the prediction of contact times is performed, that is, the best contact time window is predicted. In some embodiments, the large model can also output the availability score of developers (for example, 1 means fully available, 0 means unavailable). For example, the input can be: Developer C is in the UTC+8 time zone, the current time is 10 pm, and the status is "offline", and the output can be an availability score of 0.

[0096] In some embodiments, the dynamic skill matching 630 includes understanding the technical essence of alarms, evaluating the current technical status, and predicting the best candidate, so that the large model can dynamically match the most suitable developer or person according to the technical characteristics of the alarms and the current skill status of developers. In some embodiments, at 631, the understanding of the technical essence of alarms is performed. That is, with the help of the large model, semantic analysis is carried out on the alarm content (such as logs, error messages) to extract the technical characteristics of the problem. In some embodiments, information such as the error log, stack information, and relevant code snippets of the code task with an error alarm can be input into the large model, and then the large model can output the technical characteristics of the code task with the error alarm (such as the involved modules, possible root causes), etc. For example, for the input to the large model can be: The alarm log shows "database connection timeout", and the output of the large model can be: The technical characteristic is "database optimization problem, involving the data storage module".

[0097] In some embodiments, at 632, the current technical status is evaluated. That is, the large model combines the skill knowledge graph of developers to judge whether their current skills match the alarm problem. In some embodiments, at 633, the best candidate is predicted. That is, according to the recent task completion situation of developers, their skill weights are dynamically adjusted. For example, if a developer who frequently handles database problems recently, the skill weight of "database optimization" will increase), and those with larger weights are ranked higher. In some embodiments, through the dynamic skill matching 630, the skill matching score of developers can be output. For example, 0.9 means a high match, and 0.3 means a low match.

[0098] In some embodiments, when receiving alarm information (such as service anomalies, code errors), the large model can extract the technical characteristics of the alarm (such as the code modules or code tasks involved, error types). At the same time, the large model can conduct a developer status assessment, including load assessment, availability assessment, and skill matching, to obtain a set of matching personnel, which can include developers with low load, currently available developers, and developers with a high skill match. After obtaining the set of matching personnel, the comprehensive score of each developer can be calculated. In some embodiments, the formula for the comprehensive score is as follows:

[0099]

[0100] where α, β, and γ are weight parameters that can be adjusted as needed.

[0101] In some embodiments, the developer with the highest score can be selected as the alarm handler based on the comprehensive score. In some embodiments, if the developer with the highest score fails to respond in a timely manner, a dynamic adjustment mechanism can be triggered to assign the alarm to the next best candidate.

[0102] By leveraging the large model to analyze the working status, task load, time zone differences, and task complexity of developers in real time, it is possible to provide intelligent decision-making support for alarm assignment.

[0103] Figure 7 FIG. shows a schematic diagram of the temporal attention mechanism 700 of the target model according to an embodiment of the present disclosure. Given that in a large software development team, the collaboration relationships and code responsibilities of code tasks are not static but dynamically adjusted over time and tasks. Therefore, in order to dynamically evaluate the collaboration relationships among developers and the priority of alarm assignment, the large model can be configured with a temporal attention mechanism. Refer to Figure 7 , the temporal attention mechanism 701 includes a time decay model 710 and an attention weight calculation 720.

[0104] In some embodiments, an exponential decay function 711 can be used to weight the historical collaboration relationships to achieve a high weight for recent collaborations 712. In some embodiments, the formula for the exponential decay function is as shown in formula (5):

[0105]

[0106] Among them, Δt is the time interval (i.e. the difference between the time when the collaboration occurred and the current time), and λ is the decay coefficient, which is used to control the speed of time decay. By giving higher weights to recent collaborations, it can be ensured that the allocation results reflect the current state of collaboration. For example, the weight of the most recent collaboration will be significantly higher than the collaboration record from a year ago, thereby improving the timeliness of the allocation results. If developers A and B have collaborated frequently in the past week, their collaboration weight will be significantly higher than the collaboration record from a year ago, and the ranking will be higher. In some embodiments, if a code task has been modified recently, the ranking of this code task will also be higher.

[0107] In some embodiments, the attention weight 720 may include extracting alarm feature vectors, calculating weights through feature fusion, and dynamically adjusting weight distribution. This method of calculating attention weights based on multi-dimensional features (such as the importance of code modules, the skill matching of developers, historical collaboration intensity, etc.) can dynamically adjust the priority of code task assignment for error alarms.

[0108] In some embodiments, at 721, alarm feature vector extraction is performed, that is, feature vectors related to alarms are extracted. For example, alarm feature vectors are extracted based on the modification frequency of code modules, the complexity, importance or level of code modules or code tasks, and the skill tags, historical contributions and current workload of developers.

[0109] In some embodiments, at 722, feature fusion is performed to calculate weights, that is, a feature fusion function (such as weighted average or neural network model) is used to calculate the comprehensive weight. For example, a weighted average or a neural network model can be used to calculate the comprehensive weight. In some embodiments, an attention mechanism can be used to weight the input features to calculate the comprehensive weight. The calculation formula is as follows:

[0110]

[0111] in, is the query vector (Query), which represents the feature vector of the alarm; is the key vector (Key), which represents the feature vector of developers and code modules; is the dimension of the feature vector, used for normalization.

[0112] In some embodiments, at 723, dynamic weight distribution adjustment is performed, that is, dynamic weight distribution adjustment is performed so that the key features have a greater impact on the allocation result. For example, when a code module or code task is more important, the system can automatically increase the collaboration weight associated with the module.

[0113] In some embodiments, a time decay model and attention weights can be combined to dynamically calculate collaboration relationships and assign priorities. The calculation formula for temporal attention fusion is as follows:

[0114]

[0115] Wherein, is the basic collaboration strength (such as historical collaboration frequency); is the time decay factor, reflecting the timeliness of collaboration; is the attention weight, which can comprehensively consider the influence of multi-dimensional features.

[0116] By this method of comprehensively considering historical data and real-time status, the weights of collaboration relationships can be dynamically adjusted to ensure that the allocation strategy adapts to the real-time changes of the team state, so as to output the optimal allocation decision.

[0117] Suppose the error alarm code involves the "order management module", and the alarm type is "high-priority defect repair". The developer information is as follows: Developer A's contribution to the order management module is 0.8, and there are 3 collaboration records in the last week; Developer B: The contribution to the order management module is 0.6, and there is no collaboration record in the last week. The time decay coefficient λ = 0.1. The matching degree between the alarm feature and Developer A is 0.9; the matching degree between the alarm feature and Developer B is 0.7.

[0118] Then, in the time decay calculation, TimeDecay_A of Developer A = 0.74; TimeDecay_B of Developer B = 0.05.

[0119] At the same time, according to the following formula (8), the AttentionWeight of Developer A can be obtained A = 0.55; the AttentionWeight of Developer B B = 0.45.

[0120]

[0121] At the same time, according to formula (7), the FinalScore of Developer A can be obtained A = 0.326; the FinalScore of Developer B B = 0.0135. Thus, the allocation priority of Developer A is significantly higher than that of Developer B. Then, ignoring the influence of other possible factors (such as whether the developer is idle at the current time), the alarm task can be assigned to Developer A.

[0122] Suppose there is a database connection timeout error in a code task; Developer A has a low current task load with a score of 0.2; Developer B has a high load with a score of 0.8; Developer A is during working hours with a score of 1; Developer B is outside working hours with a score of 0; The skill weight of "database optimization" for Developer A is 0.9, and for Developer B is 0.7.

[0123] Then we can get: The comprehensive score of Developer A = ; For Developer B: The comprehensive score = . At this time, the code task with database connection timeout can be assigned to Developer A.

[0124] If, on this basis, Developer A fails to respond to the alarmed code task within the specified time. Then, the status of other developers can be re-evaluated, the next developer with the highest comprehensive score (such as Developer C) can be selected, and the code task with escalated alarm can be reassigned to Developer C.

[0125] From the above description for Figure 7 , it can be seen that the temporal attention mechanism can dynamically adjust the collaboration relationship and assign priorities by introducing a time decay model and attention weight calculation.

[0126] Figure 8 FIG. shows a schematic diagram of the intelligent allocation and dynamic adjustment 800 of model-based code tasks according to an embodiment of the present disclosure. After completing the data foundation construction, dynamic state perception, and temporal attention calculation, an intelligent allocation can be achieved with the help of a comprehensive scoring model, and the adjustment of the dynamic mechanism is supported. As Figure 8 shown, the intelligent allocation and dynamic adjustment 801 can be implemented through a comprehensive scoring model 810 and a dynamic adjustment mechanism 820.

[0127] Referring to Figure 8 , the function of the comprehensive scoring model 810 can be implemented by combining the collaboration network score 811, the skill matching degree 812, and the time decay factor 813. In some embodiments, the calculation formula of the comprehensive score can be as shown in the following formula (9):

[0128]

[0129] Where, BaseScore is the basic collaboration intensity, TimeDecay is the time decay factor, AttentionWeight is the attention weight, and ExpertiseLevel is the professionalism score.

[0130] Through this multi-dimensional comprehensive scoring calculation method, the accuracy and fairness of the assignment of code tasks with error alarms can be ensured.

[0131] Continuing to refer toFigure 8 , the dynamic adjustment mechanism 820 can be implemented by means of a task escalation process 821 and a reallocation mechanism 822. In some embodiments, when the originally assigned developer fails to respond in a timely manner, the task escalation process 821 and the reallocation mechanism 822 can be automatically triggered. For example, if developer A fails to process the error alarm code task within the specified time, the error alarm code task can be assigned to the next best candidate. By this method, it is possible to avoid affecting the overall efficiency due to the delayed response of individual developers and improve the reliability of the error alarm code task being processed.

[0132] Thus, according to the solution of the embodiments of the present disclosure, by virtue of the model capabilities of the target model, it is possible to achieve in-depth technical understanding and draw a real-time and accurate ability portrait. Therefore, when a code task goes wrong, it is possible to dynamically assign the faulty code task to relevant personnel according to the current status of relevant personnel to achieve the maintenance of the code task, ensuring the reliability and timeliness of the faulty code task being processed, thereby enhancing the user experience.

[0133] Figure 9 FIG. shows a block diagram of a device 900 for allocating code tasks according to some embodiments of the present disclosure. As Figure 9 shown, the device 900 includes a data basis determination module 902 configured to determine a data basis for the submission history information based on the submission history information of the code task. The submission history information includes task information, personnel information, and personnel skill information. The data basis includes at least one of an ownership portrait of each code task and a modification behavior pattern for each code task. The device 900 further includes a knowledge graph determination module 904 configured to determine a knowledge graph associated with personnel, skills, and code tasks by the target model based on the determined data basis. The target model is configured with a time decay model and an attention mechanism. The knowledge graph includes the skills, workload, collaboration relationships, and current status of personnel. The device 900 further includes a personnel set determination module 906 configured to determine a set of personnel matching each code task by the target model based on each code task and the knowledge graph. In addition, the device 900 further includes a personnel allocation module 908 configured to, in response to a code task going wrong, assign the code task to the personnel matching the code task by the target model based on the comprehensive scores of each person in the personnel set. The comprehensive scores are determined based on the knowledge graph and the time decay coefficient of each person.

[0134] Figure 10 FIG. shows a block diagram of an electronic device 1000 according to certain embodiments of the present disclosure. Figure 10 FIG. shows a block diagram of an electronic device 1000 according to certain embodiments of the present disclosure. The device 1000 may be the device or apparatus described in the embodiments of the present disclosure. As Figure 10As shown, device 1000 includes a central processing unit (CPU) and / or a graphics processing unit (GPU) 1001, which can perform various appropriate actions and processes according to computer program instructions stored in a read-only memory (ROM) 1002 or computer program instructions loaded from a storage unit 1008 into a random access memory (RAM) 1003. In the RAM 1003, various programs and data required for the operation of the device 1000 can also be stored. The CPU / GPU 1001, ROM 1002, and RAM 1003 are connected to each other via a bus 1004. An input / output (I / O) interface 1005 is also connected to the bus 1004. Although not shown in Figure 10 , device 1000 may further include a coprocessor.

[0135] Multiple components in the device 1000 are connected to the I / O interface 1005, including: an input unit 1006, such as a keyboard, a mouse, etc.; an output unit 1007, such as various types of displays, speakers, etc.; a storage unit 1008, such as a magnetic disk, an optical disc, etc.; and a communication unit 1009, such as a network card, a modem, a wireless communication transceiver, etc. The communication unit 1009 allows the device 1000 to exchange information / data with other devices via a computer network such as the Internet and / or various telecommunication networks.

[0136] Each of the methods or processes described above can be executed by the CPU / GPU 1001. For example, in some embodiments, the method can be implemented as a computer software program tangibly embodied in a machine-readable medium, such as the storage unit 1008. In some embodiments, part or all of the computer program can be loaded and / or installed onto the device 1000 via the ROM 1002 and / or the communication unit 1009. When the computer program is loaded into the RAM 1003 and executed by the CPU / GPU 1001, one or more steps or actions of the methods or processes described above can be executed.

[0137] In some embodiments, the methods and processes described above can be implemented as a computer program product. The computer program product may include a computer-readable storage medium having thereon computer-readable program instructions for performing various aspects of the present disclosure.

[0138] A computer-readable storage medium can be a tangible device that can retain and store instructions for use by an instruction execution device. A computer-readable storage medium may be, for example, but is not limited to, an electrical storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. More specific examples (a non-exhaustive list) of the computer-readable storage medium include: a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), a static random access memory (SRAM), a portable compact disc read-only memory (CD-ROM), a digital versatile disc (DVD), a memory stick, a floppy disk, a mechanically encoded device, such as a punched card or raised structures in grooves having instructions stored thereon, and any suitable combination of the foregoing. The computer-readable storage medium as used herein is not construed as being a transient signal per se, such as a radio wave or other freely propagating electromagnetic wave, an electromagnetic wave propagating through a waveguide or other transmission medium (e.g., an optical pulse through an optical fiber cable), or an electrical signal transmitted through a wire.

[0139] The computer-readable program instructions described herein can be downloaded from a computer-readable storage medium to various computing / processing devices, or downloaded to an external computer or external storage device via a network, such as the Internet, a local area network, a wide area network, and / or a wireless network. The network may include a copper transmission cable, an optical fiber transmission, a wireless transmission, a router, a firewall, a switch, a gateway computer, and / or an edge server. A network adapter card or network interface in each computing / processing device receives the computer-readable program instructions from the network and forwards the computer-readable program instructions for storage in a computer-readable storage medium in each computing / processing device.

[0140] The computer program instructions for performing the operations of the present disclosure may be assembly instructions, instruction set architecture (ISA) instructions, machine instructions, machine-related instructions, microcode, firmware instructions, state-setting data, or source code or object code written in any combination of one or more programming languages, including object-oriented programming languages and conventional procedural programming languages. The computer-readable program instructions may be executed entirely on the user's computer, partially on the user's computer, executed as a stand-alone software package, partially on the user's computer and partially on a remote computer, or entirely on the remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer through any type of network - including a local area network (LAN) or a wide area network (WAN) - or, alternatively, may be connected to an external computer (e.g., through the Internet using an Internet service provider). In some embodiments, by using the state information of the computer-readable program instructions to customize an electronic circuit, such as a programmable logic circuit, a field-programmable gate array (FPGA), or a programmable logic array (PLA), the electronic circuit can execute the computer-readable program instructions to implement various aspects of the present disclosure.

[0141] These computer-readable program instructions may be provided to a processing unit of a general-purpose computer, a special-purpose computer, or other programmable data processing apparatus, thereby producing a machine such that when these instructions are executed by the processing unit of the computer or other programmable data processing apparatus, a means for implementing the functions / actions specified in one or more blocks of the flowchart and / or block diagram is produced. The computer-readable program instructions may also be stored in a computer-readable storage medium, and these instructions cause a computer, a programmable data processing apparatus, and / or other devices to operate in a specific manner, so that the computer-readable medium storing the instructions includes a manufactured article that includes instructions for implementing various aspects of the functions / actions specified in one or more blocks of the flowchart and / or block diagram.

[0142] The computer-readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device, such that a series of operation steps are executed on the computer, other programmable data processing apparatus, or other device to produce a computer-implemented process, so that the instructions executed on the computer, other programmable data processing apparatus, or other device implement the functions / actions specified in one or more blocks of the flowchart and / or block diagram.

[0143] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of devices, methods, and computer program products according to various embodiments of the present disclosure. In this regard, each block in the flowchart or block diagram may represent a module, a segment of a program, or a portion of an instruction, which contains one or more executable instructions for implementing a specified logical function. In some alternative implementations, the functions noted in the blocks may occur in a different order than noted in the accompanying drawings. For example, two consecutive blocks may actually be executed substantially in parallel, or they may sometimes be executed in the 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 by a dedicated hardware-based system that performs the specified functions or actions, or by a combination of dedicated hardware and computer instructions.

[0144] The embodiments of the present disclosure have been described above. The above description is exemplary, not exhaustive, and is not limited to the disclosed embodiments. Many modifications and variations are obvious to those of ordinary skill in the art in the technical field without departing from the scope and spirit of the described embodiments. The selection of the terms used herein is intended to best explain the principles of the embodiments, the practical application, or the technical improvement of the technology in the market, or to enable other ordinary skilled persons in the technical field to understand the embodiments disclosed herein.

[0145] Some example implementations of the present disclosure are listed below.

[0146] Example 1. A method for allocating code tasks, comprising:

[0147] Based on the submission history information of the code tasks, determining a data basis for the submission history information, the submission history information including task information, personnel information, and personnel skill information, the data basis including at least one of the ownership profile of each code task and the modification behavior pattern for each code task;

[0148] Determining, by a target model based on the determined data basis, a knowledge graph associated with personnel, skills, and code tasks, the target model being configured with a time decay model and an attention mechanism, the knowledge graph including the skills, workload, collaboration relationships, and current status of the personnel;

[0149] Determining, by the target model based on each code task and the knowledge graph, a set of personnel matching each code task; and

[0150] In response to an error in the code task, the target model assigns the code task to a person matching the code task based on the comprehensive scores of each person in the personnel set, and the comprehensive scores are determined based on the knowledge graph and the time decay coefficient of each person.

[0151] Example 2. The method according to Example 1, wherein determining the data basis for the submission history information based on the submission history information of the code task includes:

[0152] In response to each code task being merged into the production branch, based on a rotation index, determining the data basis for the submission history information.

[0153] Example 3. The method according to any one of Examples 1-2, wherein in response to each code task being merged into the production branch, determining the data basis for the submission history information based on a rotation index includes:

[0154] Based on the submission history information, determining the ownership portrait of each code task; and

[0155] Based on the submission history information, determining the modification behavior pattern for each code task; and

[0156] Based on the ownership portrait and the modification behavior pattern, determining a collaboration network, where the collaboration network indicates the intensity of the collaboration relationship between each person.

[0157] Example 4. The method according to any one of Examples 1-3, wherein determining the ownership portrait of each code task based on the submission history information includes:

[0158] Based on the submission history information, determining the contribution degree of each person to each code task;

[0159] Based on a time decay model, sorting each code task; and

[0160] Based on the contribution degree, for each sorted code task, identifying the first responsible person and the second responsible person for each code task.

[0161] Example 5. The method according to any one of Examples 1-4, wherein determining the modification behavior pattern for each code task based on the submission history information includes:

[0162] Based on the submission history information, determining the task change type for each code task, where the task change type includes at least one of function development, defect repair, and task refactoring;

[0163] Based on the submission history information, determine the skill characteristics of each person and the degree of participation of each person in each code task; and

[0164] Based on the task change type for each code task, the skill characteristics of each person, and the degree of participation of each person in each code task, determine a skill characteristic profile for each person.

[0165] Example 6. The method according to any one of Examples 1-5, wherein determining the collaboration network based on the ownership profile and the modification behavior pattern includes:

[0166] Determine the collaboration history between each person and another person, the collaboration history including the collaboration frequency and the collaboration scope; and

[0167] Based on the collaboration history, determine a collaboration relationship graph, where the nodes of the collaboration relationship graph indicate persons and the edges of the collaboration relationship graph indicate collaboration relationship weights; and

[0168] Based on the collaboration relationship graph, determine the core persons and the professional persons.

[0169] Example 7. The method according to any one of Examples 1-6, wherein the target model determines a knowledge graph associated with persons, skills, and code tasks based on the determined data foundation, including:

[0170] The language model determines at least one of the technical understanding and the development intention for each code task based on the determined data foundation; and

[0171] The language model updates the knowledge graph based on the technical understanding and the development intention for each code task.

[0172] Example 8. The method according to any one of Examples 1-7, wherein the target model determines a set of persons matching each code task based on each code task and the knowledge graph, including:

[0173] For each person in the set of persons associated with each code task, determine the current workload of each person; and

[0174] For each person in the set of persons associated with each code task, determine whether each person is in a responsive state; and

[0175] For each person in the set of persons associated with each code task, determine the current skill state of each person; and

[0176] Determine a set of personnel matching each code task based on the comprehensive scores of the current workload, the responsive status, and the current skill status of each person associated with each code task.

[0177] Example 9. According to the method described in any one of Examples 1-8, wherein in response to an error in the code task, the target model assigns the code task to a person matching the code task based on the comprehensive scores of each person in the set of personnel, including:

[0178] The target model determines the weight of each of the following based on the priority of the code task:

[0179] The weight of the current workload of each person in the set of personnel matching the code task;

[0180] The weight of the current responsive status of each person in the set of personnel matching the code task; and

[0181] The weight of the current skill status of each person in the set of personnel matching the code task;

[0182] Based on the comprehensive weight of each item and the time decay coefficient of each person in the set of personnel matching the code task, determine the comprehensive score of each person in the set of personnel matching the code task; and

[0183] Based on the comprehensive score, assign the code task to a person matching the code task.

[0184] Example 10. According to the method described in any one of Examples 1-9, the comprehensive weight is determined by the target model configured with a time decay model and an attention mechanism, and the time decay coefficient is determined based on an exponential decay function and a collaboration relationship weight.

[0185] Example 11. According to the method described in any one of Examples 1-10, further comprising:

[0186] In response to the person matching the code task not responding to the assignment within a predetermined time, re-determine the comprehensive score of each person in the set of personnel matching the code task; and

[0187] Based on the re-determined comprehensive score, re-assign the code task to a person matching the code task.

[0188] Example 12. A device for assigning code tasks, comprising:

[0189] A data basis determination module, configured to determine a data basis for the submission history information based on the submission history information of code tasks, where the submission history information includes task information, personnel information, and personnel skill information, and the data basis includes at least one of an ownership portrait of each code task and a modification behavior pattern for each code task;

[0190] A knowledge graph determination module, configured to determine a knowledge graph associated with personnel, skills, and code tasks by a target model based on the determined data basis, where the target model is configured with a time decay model and an attention mechanism, and the knowledge graph includes the skills, workload, collaboration relationships, and current status of personnel;

[0191] A personnel set determination module, configured to determine a set of personnel matching each code task by the target model based on each code task and the knowledge graph; and

[0192] A comprehensive score determination module, configured to, in response to a code task error, assign the code task to a personnel matching the code task by the target model based on the comprehensive scores of each personnel in the personnel set, where the comprehensive scores are determined based on the knowledge graph and the time decay coefficient of each personnel.

[0193] Example 13. The apparatus according to Example 12, wherein the data basis determination module includes:

[0194] A first determination module, configured to determine the data basis for the submission history information based on a cyclic index in response to each code task being merged into the production branch.

[0195] Example 14. The apparatus according to any one of Examples 12-13, wherein the first determination module includes:

[0196] A second determination module, configured to determine an ownership portrait of each code task based on the submission history information; and

[0197] A third determination module, configured to determine a modification behavior pattern for each code task based on the submission history information; and

[0198] A fourth determination module, configured to determine a collaboration network based on the ownership portrait and the modification behavior pattern, where the collaboration network indicates the intensity of the collaboration relationship between each personnel.

[0199] Example 15. The apparatus according to any one of Examples 12-14, wherein the second determination module includes:

[0200] A fifth determination module, configured to determine the contribution degree of each person to each code task based on the submission history information;

[0201] A sorting module, configured to sort each code task based on a time decay model; and

[0202] A representation module, configured to identify a first person in charge and a second person in charge of each code task based on the contribution degree for each sorted code task.

[0203] Example 16. The apparatus according to any one of Examples 12-15, wherein the third determination module includes:

[0204] A sixth determination module, configured to determine a task change type for each code task based on the submission history information, where the task change type includes at least one of function development, defect repair, and task reconstruction;

[0205] A seventh determination module, configured to determine the skill characteristics of each person and the participation degree of each person in each code task based on the submission history information; and

[0206] An eighth determination module, configured to determine a skill characteristic portrait for each person based on the task change type for each code task, the skill characteristics of each person, and the participation degree of each person in each code task.

[0207] Example 17. The apparatus according to any one of Examples 12-16, wherein the fourth determination module includes:

[0208] A ninth determination module, configured to determine the collaboration history between each person and another person, where the collaboration history includes collaboration frequency and collaboration scope; and

[0209] A tenth determination module, configured to determine a collaboration relationship graph based on the collaboration history, where the nodes of the collaboration relationship graph indicate persons and the edges of the collaboration relationship graph indicate collaboration relationship weights; and

[0210] An eleventh determination module, configured to determine core persons and professional persons based on the collaboration relationship graph.

[0211] Example 18. The apparatus according to any one of Examples 12-17, wherein the knowledge graph determination module includes:

[0212] A twelfth determination module, configured to determine at least one of technical understanding and development intention for each code task by a language model based on the determined data foundation; and

[0213] An update module, configured to update the knowledge graph by a language model based on the technical understanding of each code task and the development intention.

[0214] Example 19. The apparatus according to any one of Examples 12 - 18, wherein the personnel set determination module includes:

[0215] A thirteenth determination module, configured to determine, for each person in the personnel set associated with each code task, the current workload of each person; and

[0216] A fourteenth determination module, configured to determine, for each person in the personnel set associated with each code task, whether each person is in a responsive state; and

[0217] A fifteenth determination module, configured to determine, for each person in the personnel set associated with each code task, the current skill state of each person; and

[0218] A sixteenth determination module, configured to determine a personnel set matching each code task based on a comprehensive score of the current workload, the responsive state, and the current skill state of each person associated with each code task.

[0219] Example 20. The apparatus according to any one of Examples 12 - 19, wherein the personnel assignment module includes:

[0220] A seventeenth determination module, configured to determine, by the target model based on the priority of the code task, the weight of each of the following:

[0221] The weight of the current workload of each person in the personnel set matching the code task;

[0222] The weight of the current responsive state of each person in the personnel set matching the code task; and

[0223] The weight of the current skill state of each person in the personnel set matching the code task;

[0224] An eighteenth determination module, configured to determine a comprehensive score of each person in the personnel set matching the code task based on the comprehensive weight of each item and the time decay coefficient of each person in the personnel set matching the code task; and

[0225] An assignment module, configured to assign the code task to a person matching the code task based on the comprehensive score.

[0226] Example 21. The device according to any one of Examples 12-20, wherein the comprehensive weight is determined by a target model configured with a time decay model and an attention mechanism, and the time decay coefficient is determined based on an exponential decay function and a collaboration relationship weight.

[0227] Example 22. The device according to any one of Examples 12-21, further comprising:

[0228] A re-determination module, configured to re-determine the comprehensive score of each person in the set of persons matching the code task in response to the person matching the code task not responding to the assignment within a predetermined time; and

[0229] A re-assignment module, configured to re-assign the code task to a person matching the code task based on the re-determined comprehensive score.

[0230] Example 23. An electronic device, comprising:

[0231] A processor; and

[0232] A memory coupled to the processor, the memory having instructions stored therein, which when executed by the processor cause the electronic device to perform actions, the actions including:

[0233] Based on the submission history information of the code task, determining a data basis for the submission history information, the submission history information including task information, personnel information, and personnel skill information, the data basis including at least one of the ownership portrait of each code task and the modification behavior pattern for each code task;

[0234] Based on the determined data basis, a target model determines a knowledge graph associated with personnel, skills, and code tasks, the target model being configured with a time decay model and an attention mechanism, the knowledge graph including the skills, workload, collaboration relationships, and current status of the personnel;

[0235] Based on each code task and the knowledge graph, the target model determines a set of persons matching each code task; and

[0236] In response to a code task error, based on the comprehensive score of each person in the set of persons, the target model assigns the code task to a person matching the code task, the comprehensive score being determined based on the knowledge graph and the time decay coefficient of each person.

[0237] Example 24. The electronic device according to Example 23, wherein determining a data basis for the submission history information based on the submission history information of the code task includes:

[0238] In response to each code task being merged into the production branch, based on a rotating index, determine the data basis for the commit history information.

[0239] Example 25. The electronic device according to any one of Examples 23-24, wherein in response to each code task being merged into the production branch, determining the data basis for the commit history information based on a rotating index includes:

[0240] Based on the commit history information, determine the ownership profile of each code task; and

[0241] Based on the commit history information, determine the modification behavior pattern for each code task; and

[0242] Based on the ownership profile and the modification behavior pattern, determine a collaboration network that indicates the strength of the collaboration relationship between each person.

[0243] Example 26. The electronic device according to any one of Examples 23-25, wherein based on the commit history information, determining the ownership profile of each code task includes:

[0244] Based on the commit history information, determine the contribution degree of each person to each code task;

[0245] Based on a time decay model, sort each code task; and

[0246] Based on the contribution degree, for each sorted code task, identify the first responsible person and the second responsible person for each code task.

[0247] Example 27. The electronic device according to any one of Examples 23-26, wherein based on the commit history information, determining the modification behavior pattern for each code task includes:

[0248] Based on the commit history information, determine the task change type for each code task, where the task change type includes at least one of function development, defect repair, and task refactoring;

[0249] Based on the commit history information, determine the skill characteristics of each person and the degree of participation of each person in each code task; and

[0250] Based on the task change type for each code task, the skill characteristics of each person, and the degree of participation of each person in each code task, determine the skill characteristic profile for each person.

[0251] Example 28. The electronic device according to any one of Examples 23-27, wherein determining the collaboration network based on the ownership portrait and the modified behavior pattern includes:

[0252] Determining the collaboration history between each person and another person, the collaboration history including the collaboration frequency and the collaboration scope; and

[0253] Based on the collaboration history, determining a collaboration relationship graph, where the nodes of the collaboration relationship graph indicate persons, and the edges of the collaboration relationship graph indicate collaboration relationship weights; and

[0254] Based on the collaboration relationship graph, determining core persons and professional persons.

[0255] Example 29. The electronic device according to any one of Examples 23-28, wherein determining the knowledge graph associated with persons, skills, and code tasks by the target model based on the determined data foundation includes:

[0256] Determining, by a language model based on the determined data foundation, at least one of technical understanding and development intention for each code task; and

[0257] Updating the knowledge graph by the language model based on the technical understanding and the development intention for each code task.

[0258] Example 30. The electronic device according to any one of Examples 23-29, wherein determining the set of persons matching each code task by the target model based on each code task and the knowledge graph includes:

[0259] For each person in the set of persons associated with each code task, determining the current workload of each person; and

[0260] For each person in the set of persons associated with each code task, determining whether each person is in a responsive state; and

[0261] For each person in the set of persons associated with each code task, determining the current skill state of each person; and

[0262] Based on the comprehensive scores of the current workload, the responsive state, and the current skill state of each person associated with each code task, determining the set of persons matching each code task.

[0263] Example 31. The electronic device according to any one of Examples 23-30, wherein in response to a code task error, assigning the code task to a person matching the code task by the target model based on the comprehensive scores of each person in the set of persons includes:

[0264] Based on the priority of the code task, the target model determines the weight of each of the following:

[0265] The weight of the current workload of each person in the set of persons matching the code task;

[0266] The weight of the current responsiveness status of each person in the set of persons matching the code task; and

[0267] The weight of the current skill status of each person in the set of persons matching the code task;

[0268] Based on the comprehensive weight of each item and the time decay coefficient of each person in the set of persons matching the code task, determine the comprehensive score of each person in the set of persons matching the code task; and

[0269] Based on the comprehensive score, assign the code task to the person matching the code task.

[0270] Example 32. The electronic device according to any one of Examples 23-31, wherein the comprehensive weight is determined by the target model configured with a time decay model and an attention mechanism, and the time decay coefficient is determined based on an exponential decay function and a collaboration relationship weight.

[0271] Example 33. The electronic device according to any one of Examples 23-32, further comprising:

[0272] In response to the person matching the code task not responding to the assignment within a predetermined time, re-determine the comprehensive score of each person in the set of persons matching the code task; and

[0273] Based on the re-determined comprehensive score, re-assign the code task to the person matching the code task.

[0274] Example 34. A computer-readable storage medium having one or more computer instructions stored thereon, wherein the one or more computer instructions are executed by a processor to implement the method according to any one of Examples 1 to 11.

[0275] Example 35. A computer program product tangibly stored on a computer-readable medium and including computer-executable instructions that, when executed by a device, cause the device to execute the method according to any one of Examples 1 to 11.

[0276] Although the present disclosure has been described in language specific to structural features and / or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. On the contrary, the specific features and acts described above are merely example forms of implementing the claims.

Claims

1. A method for allocating code tasks, comprising: Based on the submission history information of code tasks, determining a data basis for the submission history information, the submission history information including task information, personnel information, and personnel skill information, the data basis including at least one of an ownership profile for each code task and a modification behavior pattern for each code task, wherein determining the modification behavior pattern for each code task includes: performing semantic analysis on the submission history information to determine the task change type for each code task; Based on the determined data basis, a target model determines a dynamic knowledge graph associated with personnel, skills, and code tasks, the target model being configured with a time decay model and an attention mechanism, the dynamic knowledge graph including the skills, workload, collaboration relationships, and current status of personnel; Based on each code task and the dynamic knowledge graph, the target model determines a set of personnel matching each code task; and In response to a code task error, based on the comprehensive score of each person in the set of personnel, the target model allocates the code task to a person matching the code task, the comprehensive score being determined based on the dynamic knowledge graph and the time decay coefficient of each person, wherein allocating the code task to a person matching the code task includes: In response to the person matching the code task not responding to the allocation within a predetermined time, re-determining the comprehensive score of each person in the set of personnel matching the code task; and Based on the re-determined comprehensive score, re-allocating the code task to a person matching the code task.

2. The method according to claim 1, wherein determining a data basis for the submission history information based on the submission history information of code tasks includes: In response to each code task being merged into the production branch, based on a rotating index, determining the data basis for the submission history information.

3. The method according to claim 2, wherein in response to each code task being merged into the production branch, determining the data basis for the submission history information based on a rotating index includes: Based on the submission history information, determining an ownership profile for each code task; And Based on the submission history information, determining a modification behavior pattern for each code task; And Based on the ownership profile and the modification behavior pattern, determining a collaboration network, the collaboration network indicating the intensity of the collaboration relationship between each person.

4. The method according to claim 3, wherein determining an ownership profile for each code task based on the submission history information includes: Based on the submission history information, determining the contribution degree of each person to each code task; Based on the time decay model, sorting for each code task; And Based on the contribution degree, for each sorted code task, identifying the first responsible person and the second responsible person for each code task.

5. The method according to claim 3, wherein determining the modification behavior pattern for each code task based on the submission history information further includes: Based on the submission history information, determining the task change type for each code task, where the task change type includes at least one of function development, defect repair, and task refactoring; Based on the submission history information, determining the skill characteristics of each person and the degree of participation of each person in each code task; And Based on the task change type for each code task, the skill characteristics of each person, and the degree of participation of each person in each code task, determining a skill characteristic portrait for each person.

6. The method according to claim 3, wherein determining the collaboration network based on the ownership portrait and the modification behavior pattern includes: Determining the collaboration history between each person and another person, where the collaboration history includes the collaboration frequency and the collaboration scope; And Based on the collaboration history, determining a collaboration relationship graph, where the nodes of the collaboration relationship graph indicate persons, and the edges of the collaboration relationship graph indicate the collaboration relationship weights; And Based on the collaboration relationship graph, determining the core persons and the professional persons.

7. The method according to claim 1, wherein the target model determines a dynamic knowledge graph associated with persons, skills, and code tasks based on the determined data foundation, including: The language model determines at least one of the technical understanding and the development intention for each code task based on the determined data foundation; And The language model updates the dynamic knowledge graph based on the technical understanding and the development intention for each code task.

8. The method according to claim 7, wherein the target model determines a set of persons matching each code task based on each code task and the dynamic knowledge graph, including: For each person in the set of persons associated with each code task, determining the current workload of each person; And For each person in the set of persons associated with each code task, determining whether each person is in a responsive state; and For each person in the set of persons associated with each code task, determining the current skill state of each person; And Based on the comprehensive scores of the current workload, the responsive state, and the current skill state of each person associated with each code task, determining a set of persons matching each code task.

9. The method according to claim 8, wherein in response to a code task error, the target model assigns the code task to a person matching the code task based on the comprehensive scores of each person in the set of persons, including: The target model determines the weight of each of the following based on the priority of the code task: The weight of the current workload of each person in the set of persons matching the code task; The weight of the current responsive state of each person in the set of persons matching the code task; And The weight of the current skill state of each person in the set of persons matching the code task; Determine the comprehensive score of each person in the set of persons matching the code task based on the comprehensive weight of each item and the time decay coefficient of each person in the set of persons matching the code task; And Based on the comprehensive score, assign the code task to the person matching the code task.

10. The method according to claim 9, wherein the comprehensive weight is determined by the target model configured with the time decay model and the attention mechanism, and the time decay coefficient is determined based on the exponential decay function and the collaboration relationship weight.

11. An apparatus for allocating code tasks, comprising: A data basis determination module configured to determine, based on the submission history information of the code task, a data basis for the submission history information, the submission history information including task information, personnel information, and personnel skill information, the data basis including at least one of the ownership portrait of each code task and the modification behavior pattern for each code task, wherein determining the modification behavior pattern for each code task includes: performing semantic analysis on the submission history information to determine the task change type for each code task; A knowledge graph determination module configured to determine, by the target model based on the determined data basis, a dynamic knowledge graph associated with persons, skills, and code tasks, the target model being configured with a time decay model and an attention mechanism, the dynamic knowledge graph including the skills, workload, collaboration relationship, and current status of the persons; A person set determination module configured to determine, by the target model based on each code task and the dynamic knowledge graph, a set of persons matching each code task; and A person allocation module configured to, in response to an error in the code task, assign the code task to the person matching the code task by the target model based on the comprehensive score of each person in the set of persons, the comprehensive score being determined based on the dynamic knowledge graph and the time decay coefficient of each person, wherein assigning the code task to the person matching the code task includes: In response to the person matching the code task not responding to the assignment within a predetermined time, re-determine the comprehensive score of each person in the set of persons matching the code task; and Based on the re-determined comprehensive score, re-assign the code task to the person matching the code task.

12. An electronic device, comprising: A processor; And A memory coupled to the processor, the memory having instructions stored therein that, when executed by the processor, cause the electronic device to perform the method according to any one of claims 1 to 10.

13. A computer program product, the computer program product being tangibly stored on a non-transitory computer-readable medium and including computer-executable instructions for performing the method according to any one of claims 1 to 10.

Images