Issue fixer recommendation method, device, equipment and readable storage medium

Abstract

The application relates to an Issue fixer recommendation method and device, equipment and a readable storage medium, relates to the open source software ecosystem field and the service recommendation technical field, and fully considers the cooperative interaction relationship between developers and Issues, that is, a cooperative interaction graph between developers and Issues is constructed according to the cooperative relationship between developers, the interaction behavior between developers and Issues and the similar relationship between Issues, feature learning is performed on the developers and Issues, and the fixer recommendation is performed by using the inner product result of the feature vectors of the developers and Issues, so that the fixer recommendation result is more comprehensive and accurate, and the Issue fixer recommendation performance is effectively improved.

Description

Technical Field

[0001] This application relates to the fields of open source software ecosystem and service recommendation technology, and in particular to an issue fixer recommendation method, apparatus, device and readable storage medium. Background Technology

[0002] Collaborative development models enable developers to jointly develop high-quality open-source software within open-source communities. Effective collaborative development can save development time and facilitate iterative evolution. GitHub, as the world's largest hosting platform for open-source and private projects, provides developers with access to code hosting and collaborative development. This open-source community offers an ITS (Issue Tracker System) module, allowing developers to submit issues to report project-related problems, record new requirements, and publish other development tasks. It also allows developers to promote project iteration and enhance their influence by resolving issues, making it a crucial pathway for promoting project development and iterative evolution within open-source communities.

[0003] In collaborative development models, software development is typically based on competitive or voluntary mechanisms, and its productivity and quality largely depend on the efficiency of developer collaboration. In many open-source projects, due to the large volume of issue submissions and the fact that most issues are not assigned to specific developers (assignees) for resolution, a large number of issues remain unresolved for extended periods, hindering project iteration and evolution. Therefore, recommending suitable developers as issue fixers has become a critical task in open-source community development management. However, the interaction between developers and issues in open-source communities is highly sparse. Learning the correlation characteristics between developers and issues from a sparse and complex collaborative development network is a major challenge in issue fixer recommendation.

[0004] In related technologies, within the open-source software community, to better recommend suitable developers for different task scenarios, recommendations are often based on the developer's expert experience (personal ability, professional knowledge, activity level, influence, etc.) or on the developer's ownership and contribution to the code. However, in most cases, due to the head effect of the developer group (i.e., a few developers own and contribute to the vast majority of the code), other developers are difficult to recommend, resulting in poor recommendation performance. Additionally, some methods focus on the interaction between the developer and the task, recommending developers based on matrix factorization (MF) or collaborative filtering (CF) through similar historical behaviors. However, when there is little explicit interaction between the developer and the task, recommendation performance is also poor. Therefore, traditional fixer recommendation often suffers from poor performance. Summary of the Invention

[0005] This application provides a method, apparatus, device, and readable storage medium for recommending issue fixers, in order to solve the problem of poor performance in issue fixer recommendation in related technologies.

[0006] Firstly, a method for recommending issue fixers is provided, including the following steps:

[0007] Each developer and each issue is set as a graph node. A developer initial node feature vector is created for each developer based on the developer's ID information and the ID information of its corresponding neighbor nodes. An issue initial node feature vector is created for each issue based on the issue's ID information, the ID information of its corresponding neighbor nodes, and the text description of the issue.

[0008] A collaborative interaction graph is constructed based on the initial node feature vectors of developers, the initial node feature vectors of issues, the collaborative relationships between developers, the interaction relationships between issues and developers, and the similarity relationships between issues.

[0009] Based on the preset node feature propagation rules and preset node feature aggregation rules, the initial node feature vector of the developer, the initial node feature vector of the issue, and the collaborative interaction graph are subjected to a preset number of feature propagation iterations and feature aggregation iterations to obtain the developer node feature vectors of each level corresponding to each developer and the issue node feature vectors of each level corresponding to each issue.

[0010] The inner product value between each Issue and each developer is determined based on the feature vectors of each level of developer nodes and the feature vectors of each level of Issue nodes.

[0011] Based on the size of the inner product, the top N developers are selected from all developers as the recommended fixers for each issue, where N is a positive integer.

[0012] In some embodiments, the formula for calculating the collaboration relationship between the various developers is as follows:

[0013] C(d j ,d k )=α*co_inner(d j ,d k )+(1-α)*co_outer(d j ,d k )

[0014] In the formula, C(d) j ,d k ) indicates developer d j and developer d k The degree of closeness of the collaborative relationship between them, co_inner(d j ,d k This indicates that the developer d belongs to the same project as a specific issue. j and developer d k The number of direct collaboration relationships generated within the Issue of the project, co_outer(d j ,d k This indicates that the developer d belongs to the same project as a specific issue. j and developer d k The number of indirect collaboration relationships generated in the relevant project Issue, α∈[0,1].

[0015] In some embodiments, the formula for calculating the interaction relationship between the Issue and the developer is:

[0016]

[0017] In the formula, I(d) j i m ) indicates developer d j and Issuei m The degree of closeness of the interaction between them, where n represents the total number of developers, com_count(d j i m (Refers to developer d) j In Issue i m The total number of comments posted in the comments section. This indicates that all developers are targeting Issue i m The total number of comments, inter_count(d j i m) indicates developer d j In Issue i m The number of times a certain role is played, β∈[0,1].

[0018] In some embodiments, the formula for calculating the similarity relationship between the various Issues is as follows:

[0019] S(i m i n )=γ*tex_sim(i m i n )+(1-γ)*co_dev(i m i n )

[0020] In the formula, S(i m i n ) indicates Issue i m and Issue i n The degree of similarity between them, tex_sim(i m i n ) indicates Issue i m and Issue i n The direct similarity between them, co_dev(i m i n ) indicates Issue i m and Issue i n The indirect similarity relationship between them, γ∈[0,1].

[0021] In some embodiments, the preset node feature propagation rules include propagation rules for collaborative relationships between developers, propagation rules for interaction relationships between developers and Issues, and propagation rules for similarity relationships between Issues.

[0022] The rules for propagating the collaborative relationships among the various developers are as follows:

[0023]

[0024] In the formula, m(d) j ,d k ) indicates from developer d j and developer d k Message embedding propagation in collaborative relationships, C(d) j ,d k ) indicates developer d j and developer d k The degree of closeness of the cooperative relationship between them Indicates developer d j The developer's initial node feature vector;

[0025] The propagation rule for the interaction relationship between the developer and the Issue is as follows:

[0026]

[0027] In the formula, m(d) j i m ) indicates from developer d j and Issue i m Message embedding propagation in interaction relationships, I(d j i m ) indicates developer d j and Issue i m The degree of closeness of the interaction between them Indicates Issue i m The initial node feature vector of the Issue;

[0028] The similarity propagation rule between Issues is as follows:

[0029]

[0030] In the formula, m(i m i n ) is from Issue i m and Issue i n Message embedding propagated in similarity relationships, S(i m i n ) indicates Issue i m and Issue i n The degree of similarity between them Indicates Issue i n The initial node feature vector of the Issue.

[0031] In some embodiments, the preset node feature aggregation rules include aggregation rules for developer node feature messages and aggregation rules for Issue node feature messages.

[0032] The aggregation rule for the developer node feature messages is as follows:

[0033]

[0034] In the formula, Indicates developer d j message aggregation of all neighboring nodes For developers d j The set of neighboring nodes, m(d) j ,d k ) indicates from developer dj and developer d k Message embedding propagation in collaborative relationships, m(d j i m ) indicates from developer d j and Issue i m The message embedding propagated in the interaction relationship, W1 and W2 are weight matrices, D(d j ,d k ) indicates that on edge (d) j ,d k The attenuation coefficient during propagation, D(d) j i m ) indicates that on edge (d) j i m The attenuation coefficient during propagation.

[0035] The aggregation rule for the feature messages of the Issue node is as follows:

[0036]

[0037] In the formula, Issuei m message aggregation of all neighboring nodes for Issue i m The set of neighboring nodes, m(i) m ,d j ) indicates from Issue i m and developer d j Message embedding propagation in interaction relationships, m(i m i n ) is from Issuei m and Issue i n The message embedding propagates in the similarity relationship, W3 and W4 are weight matrices, and D(i m ,d j ) indicates that on edge (i m ,d j The attenuation coefficient during propagation, D(i) m i n ) indicates that on edge (i m i n The attenuation coefficient during propagation.

[0038] In some embodiments, determining the inner product value between each Issue and each developer based on the feature vectors of developer nodes and Issue nodes of each order includes:

[0039] The feature vectors of each level of developer node corresponding to each developer are concatenated to obtain the feature vector of the higher-order developer node corresponding to each developer. The feature vectors of each level of issue node corresponding to each issue are concatenated to obtain the feature vector of the higher-order issue node corresponding to each issue.

[0040] The inner product between each Issue and each developer is calculated based on the feature vectors of the higher-order Issue nodes and the feature vectors of the higher-order developer nodes.

[0041] Secondly, an Issue Repairer Recommendation Device is provided, comprising:

[0042] The creation unit is used to set each developer and each issue as a graph node, and to create an initial node feature vector for each developer based on the developer's ID information and the ID information of its corresponding neighbor nodes, and to create an initial node feature vector for each issue based on the issue's ID information, the ID information of its corresponding neighbor nodes, and the text description content of the issue.

[0043] The building unit is used to construct a collaborative interaction graph based on the initial node feature vector of the developer, the initial node feature vector of the issue, the collaborative relationship between the developers, the interaction relationship between the issue and the developer, and the similarity relationship between the issues.

[0044] The processing unit is used to perform a preset number of feature propagation iterations and feature aggregation iterations on the developer's initial node feature vector, the issue's initial node feature vector, and the collaboration interaction graph based on preset node feature propagation rules and preset node feature aggregation rules, so as to obtain the developer node feature vectors of each level corresponding to each developer and the issue node feature vectors of each level corresponding to each issue.

[0045] The computational unit is used to determine the inner product value between each Issue and each developer based on the feature vectors of each level of developer nodes and the feature vectors of each level of Issue nodes.

[0046] The recommendation unit is used to determine the top N developers from all developers based on the size of the inner product value as the recommended fixers for each issue, where N is a positive integer.

[0047] Thirdly, an Issue fixer recommendation device is provided, comprising: a memory and a processor, wherein the memory stores at least one instruction, and the at least one instruction is loaded and executed by the processor to implement the aforementioned Issue fixer recommendation method.

[0048] Fourthly, a computer-readable storage medium is provided, the computer storage medium storing a computer program that, when executed by a processor, implements the aforementioned Issue fixer recommendation method.

[0049] This application provides a method, apparatus, device, and readable storage medium for recommending issue fixers. The method includes setting each developer and each issue as graph nodes, creating an initial node feature vector for each developer based on the developer's ID information and the ID information of its corresponding neighbor nodes, creating an initial node feature vector for each issue based on the issue's ID information, the ID information of its corresponding neighbor nodes, and the text description of the issue; and using the initial node feature vectors of developers, issue initial node feature vectors, the collaborative relationships between developers, the interaction relationships between issues and developers, and the various issues... This application constructs a collaborative interaction graph based on the similarity relationships between developers and issues. It performs a preset number of feature propagation and aggregation iterations on the initial node feature vectors of developers, initial node feature vectors of Issues, and the collaborative interaction graph, based on preset node feature propagation and aggregation rules. This yields the feature vectors of each level of developer nodes and each level of Issue nodes. The inner product value between each Issue and each developer is determined based on these feature vectors. The top N developers are selected as the recommended fixers for each Issue based on the size of the inner product value. This application fully considers the collaborative interaction relationships between developers and Issues. Specifically, it constructs a collaborative interaction graph between developers and Issues based on their collaborative relationships, interaction behaviors, and similarity relationships. Furthermore, it performs feature learning on both developers and Issues and uses the inner product result of their feature vectors to recommend fixers, making the fixer recommendations more comprehensive and accurate, effectively improving the performance of Issue fixer recommendations. Attached Figure Description

[0050] To more clearly illustrate the technical solutions in the embodiments of this application, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0051] Figure 1 A flowchart illustrating an Issue fixer recommendation method provided in this application embodiment;

[0052] Figure 2 A schematic diagram of the structure of an Issue repairer recommendation model provided in this application embodiment;

[0053] Figure 3 A schematic diagram of an Issue Healer Recommendation Device provided in this application embodiment;

[0054] Figure 4 This is a schematic diagram of the structure of an Issue Repairer Recommendation Device provided in an embodiment of this application. Detailed Implementation

[0055] To make the objectives, technical solutions, and advantages of the embodiments of this application clearer, the technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0056] This application provides a method, apparatus, device, and readable storage medium for recommending issue fixers, which can solve the problem of poor performance of issue fixer recommendation in related technologies.

[0057] See Figure 1 and Figure 2 This application provides a method for recommending issue fixers, including the following steps:

[0058] Step S10: Set each developer and each issue as a graph node, and create an initial node feature vector for each developer based on the developer's ID information and the ID information of its corresponding neighbor nodes. Create an initial node feature vector for each issue based on the issue's ID information, the ID information of its corresponding neighbor nodes, and the text description of the issue.

[0059] As an example, in this embodiment, each Issue and each developer are treated as graph nodes. The ID information of all Issues and their corresponding neighboring node IDs (i.e., the location information of each Issue in the network) and text descriptions (such as title, content, and code file path) are extracted from the acquired original dataset. Then, Doc2vec (Document Vectorization Representation Model) is used in the node feature embedding layer to perform feature embedding based on the ID information of each Issue, its corresponding neighboring node IDs, and the text description, to obtain the initial node feature vector for each Issue. Simultaneously, the ID information of all developers and their corresponding neighboring node IDs (i.e., the location information of each developer in the network) are extracted from the acquired original dataset, and Doc2vec is used in the node feature embedding layer to perform feature embedding based on the ID information of each developer and its corresponding neighboring node IDs, to obtain the initial node feature vector for each developer.

[0060] Step S20: Construct a collaborative interaction graph based on the initial node feature vectors of developers, the initial node feature vectors of issues, the collaborative relationships between developers, the interaction relationships between issues and developers, and the similarity relationships between issues;

[0061] Furthermore, the formula for calculating the collaborative relationship between the various developers is as follows:

[0062] C(d j ,d k )=α*co_inner(d j ,d k )+(1-α)*co_outer(d j ,d k )

[0063] In the formula, C(d) j ,d k ) indicates developer d j and developer d k The degree of closeness of the collaborative relationship between them, co_inner(d j ,d k This indicates that the core developers (d) simultaneously belong to the project to which a particular issue belongs. j and core developer d k The number of direct collaboration relationships generated within the Issue of the project, co_outer(d j ,d k This indicates a regular developer d who is simultaneously affiliated with the project to which a particular issue belongs. j The number of indirect collaborations between developer dk and the project issue, α∈[0,1].

[0064] Furthermore, the formula for calculating the interaction relationship between the Issue and the developer is as follows:

[0065]

[0066] In the formula, I(d) j i m ) indicates developer d j and Issue i m The degree of closeness of the interaction between them, where n represents the total number of developers, com_count(d j i m (Refers to developer d) j In Issue i m The total number of comments posted in the comments section. This indicates that all developers are targeting Issue i m The total number of comments posted. And inter_count(d j i m ) indicates developer d j In Issue i m The number of times a certain role is played, β∈[0,1].

[0067] Furthermore, the formula for calculating the similarity relationship between the various Issues is as follows:

[0068] S(i m i n )=γ*tex_sim(i m i n )+(1-γ)*co_dev(i m i n )

[0069] In the formula, S(i m i n ) indicates Issue i m and Issue i n The degree of similarity between them, tex_sim(i m i n ) indicates Issue i m and Issue i n The direct similarity between them, co_dev(i m i n ) indicates Issue i m and Issue i n The indirect similarity relationship between them, γ∈[0,1].

[0070] As an example, in this embodiment, the positional relationship between the developer and the issue can be determined based on the initial node feature vector of the developer and the initial node feature vector of the issue. The collaborative relationship between the developers, the interaction relationship between the issue and the developer, and the similarity relationship between the issues are mapped as edges, thereby constructing a collaborative interaction graph network between the developer and the issue.

[0071] Step S20 includes the following specific implementation steps:

[0072] Step S201: Map the collaboration relationships between developers as edges. If two developers both perform development actions (such as creating an issue, closing an issue, commenting on an issue, or submitting code) on the same issue, then a collaboration relationship is considered to have been established between the two developers. Furthermore, the more times two developers collaborate on different issues, the closer their collaboration relationship is. The closeness of the collaboration relationship is calculated as follows:

[0073] C(d j ,d k )=α*co_inner(d j ,d k )+(1-α)*co_outer(d j ,d k )

[0074] In the formula, C(d) j ,d k ) indicates developer d j and developer d k The degree of closeness of the collaborative relationship between them, co_inner(d j ,d k This indicates that the core developers (d) simultaneously belong to the project to which a particular issue belongs. j and core developer d k The number of direct collaboration relationships generated within the Issue of the project, co_outer(d j ,d k This indicates a regular developer d who is simultaneously affiliated with the project to which a particular issue belongs. j and developer d k The number of indirect collaboration relationships generated within the project's Issue, where, when developer d j and developer d k When there is no collaborative relationship between them, co_inner(d j ,d k ) and co_outer(d j ,d kAll are 0; α∈[0,1], which is the weight coefficient used to adjust the direct and indirect cooperation relationships. This weight coefficient can be obtained through model training.

[0075] Step S202: Map the interaction relationship between the Issue and the developer as edges. Since the interaction between the developer and the Issue is closely related to four types of behavior: developer creating an Issue, developer commenting on an Issue, developer closing an Issue, and developer being assigned to resolve an Issue, the calculation process for the closeness of the interaction relationship between the developer and the Issue based on these interaction behaviors is as follows:

[0076]

[0077] In the formula, I(d) j i m ) indicates developer d j and Issue i m The degree of closeness of the interaction between them, where n represents the total number of developers, com_count(d j i m (Refers to developer d) j In Issue i m The total number of comments posted in the comments section. This indicates that all developers are targeting Issue i m The total number of comments posted. And inter_count(d j i m ) indicates developer d j In Issue i m The number of times a developer d assumes a particular role (such as creator, closure, or allocator). j with Issue i m When there is no interaction relationship between them, com_count(d j i m ) and inter_count(d j i m All are 0; β∈[0,1], which is used to adjust com_count(d j i m ) and inter_count(d j i m The weighting coefficients for these two relationships can be obtained through model training.

[0078] Step S203: Map the similarity relationships between Issues to edges. Since the content of Issues may be similar, the text cosine similarity between Issues can be defined as a direct similarity relationship, and its calculation method is as follows:

[0079]

[0080] In the formula, tex_sim(i m i n ) indicates Issue i m and Issue i n The direct similarity between them, e m and e n They represent Issue i respectively m and Issue i n The text vector is learned by Doc2Vec. Wherein, when Issue i m and Issue i n If there is no similarity between the contents, then tex_sim(i m i n The value of ) is 0.

[0081] Different issues may share multiple developers, and the more developers who share them, the higher the similarity between the issues. Therefore, this can be defined as an indirect similarity relationship between issues. The formula for calculating the similarity relationship between different issues is as follows:

[0082] S(i m i n )=γ*tex_sim(i m i n )+(1-γ)*co_dev(i m i n )

[0083] In the formula, S(i m i n ) indicates Issue i m and Issue i n The degree of similarity between them, tex_sim(i m i n ) indicates Issue i m and Issue i n The direct similarity between them, co_dev(i m i n ) indicates Issue i m and Issue i nThe indirect similarity between them, and co_dev(i m i n The value of ) is equal to Issue i m and Issue i n The number of co-developers; γ∈[0,1], which is used to adjust tex_sim(i m i n ) and co_dev(i m i n The weighting coefficients for these two relationships can be obtained through model training.

[0084] Step S204: Using developers and Issue as nodes, and based on the three types of edges involved in steps S201, S202 and S203, a collaborative interaction graph network between developers and Issue can be constructed.

[0085] Step S30: Based on the preset node feature propagation rules and preset node feature aggregation rules, perform a preset number of feature propagation iterations and feature aggregation iterations on the developer's initial node feature vector, the issue's initial node feature vector, and the collaboration interaction graph to obtain the developer node feature vectors of each level corresponding to each developer and the issue node feature vectors of each level corresponding to each issue.

[0086] Furthermore, the preset node feature propagation rules include the propagation rules for collaborative relationships between developers, the propagation rules for interaction relationships between developers and Issues, and the propagation rules for similarity relationships between Issues.

[0087] The rules for propagating the collaborative relationships among the various developers are as follows:

[0088]

[0089] In the formula, m(d) j ,d k ) indicates from developer d j and developer d k Message embedding propagation in collaborative relationships, C(d) j ,d k ) indicates developer d j and developer d k The degree of closeness of the cooperative relationship between them Indicates developer d j The developer's initial node feature vector;

[0090] The propagation rule for the interaction relationship between the developer and the Issue is as follows:

[0091]

[0092] In the formula, m(d) j i m ) indicates from developer d j and Issue i m Message embedding propagation in interaction relationships, I(d j i m ) indicates developer d j and Issue i m The degree of closeness of the interaction between them Indicates Issue i m The initial node feature vector of the Issue;

[0093] The similarity propagation rule between Issues is as follows:

[0094]

[0095] In the formula, m(i m i n ) is from Issue i m and Issue i n Message embedding propagated in similarity relationships, S(i m i n ) indicates Issue i m and Issue i n The degree of similarity between them Indicates Issue i n The initial node feature vector of the Issue.

[0096] Furthermore, the preset node feature aggregation rules include aggregation rules for developer node feature messages and aggregation rules for Issue node feature messages.

[0097] The aggregation rule for the developer node feature messages is as follows:

[0098]

[0099] In the formula, Indicates developer d j message aggregation of all neighboring nodes For developers d j The set of neighboring nodes, m(d) j ,d k ) indicates from developer d j and developer d k Message embedding propagation in collaborative relationships, m(d j i m ) indicates from developer d jand Issue i m The message embedding propagated in the interaction relationship, W1 and W2 are weight matrices, D(d j ,d k ) indicates that on edge (d) j ,d k The attenuation coefficient during propagation, D(d) j i m ) indicates that on edge (d) j i m The attenuation coefficient during propagation.

[0100] The aggregation rule for the feature messages of the Issue node is as follows:

[0101]

[0102] In the formula, for Issue i m message aggregation of all neighboring nodes for Issue i m The set of neighboring nodes, m(i) m ,d j ) indicates from Issue i m and developer d j Message embedding propagation in interaction relationships, m(i m i n ) is from Issuei m and Issue i n The message embedding propagates in the similarity relationship, W3 and W4 are weight matrices, and D(i m ,d j ) indicates that on edge (i m ,d j The attenuation coefficient during propagation, D(i) m i n ) indicates that on edge (i m i n The attenuation coefficient during propagation.

[0103] As an example, in this embodiment, the propagation rules of developer node features and issue node features are determined based on the collaborative relationship between developers, the interaction relationship between Issue and developers, and the similarity relationship between Issues.

[0104] The rules for propagating collaboration relationships among developers are as follows:

[0105]

[0106] In the formula, m(d) j ,dk ) indicates from developer d j and developer d k Message embedding propagation in collaborative relationships, C(d) j ,d k ) indicates developer d j and developer d k The degree of closeness of the cooperative relationship between them Indicates developer d j The developer's initial node feature vector;

[0107] The propagation rule for the interaction relationship between the developer and the Issue is as follows:

[0108]

[0109] In the formula, m(d) j i m ) indicates from developer d j and Issue i m Message embedding propagation in interaction relationships, I(d j i m ) indicates developer d j and Issue i m The degree of closeness of the interaction between them Indicates Issue i m The initial node feature vector of the Issue;

[0110] The similarity propagation rule between Issues is as follows:

[0111]

[0112] In the formula, m(i m i n ) is from Issue i m and Issue i n Message embedding propagated in similarity relationships, S(i m i n ) indicates Issue i m and Issue i n The degree of similarity between them Indicates Issue i n The initial node feature vector of the Issue.

[0113] Based on the feature vectors of the developer and issue nodes after message propagation, the aggregation rules for the features of the developer node and issue node are determined to update the features of the developer node and issue node.

[0114] Specifically, for low-level developer nodes and Issue nodes, message aggregation is performed on neighboring nodes based on the propagation and update method of node characteristic messages.

[0115] Specifically, the aggregation rules for developer node feature messages are as follows:

[0116]

[0117] In the formula, Indicates developer d j message aggregation of all neighboring nodes For developers d j The set of neighboring nodes, m(d) j ,d k ) indicates from developer d j and developer d k Message embedding propagation in collaborative relationships, m(d j i m ) indicates from developer d j and Issue i m The message embedding propagated in the interaction relationship, W1 and W2 are weight matrices, D(d j ,d k ) indicates that on edge (d) j ,d k The attenuation coefficient during propagation, D(d) j i m ) indicates that on edge (d) j i m The attenuation coefficient during propagation.

[0118] Wherein, D(d) j ,d k The calculation method for ) is as follows:

[0119]

[0120] In the formula, For developers d k The set of neighboring nodes.

[0121] D(d j i m The calculation method for ) is as follows:

[0122]

[0123] In the formula, for Issue i m The set of neighboring nodes.

[0124] The aggregation rules for Issue node feature messages are as follows:

[0125]

[0126] In the formula, for Issue i m message aggregation of all neighboring nodes for Issue i m The set of neighboring nodes, m(i) m ,d j ) indicates from Issue i m and developer d j Message embedding propagation in interaction relationships, m(i m i n ) is from Issuei m and Issue i n The message embedding propagates in the similarity relationship, W3 and W4 are weight matrices, and D(i m ,d j ) indicates that on edge (i m ,d j The attenuation coefficient during propagation, D(i) m i n ) indicates that on edge (i m i n The attenuation coefficient during propagation.

[0127] Where D(i) m ,d j The calculation method for ) is as follows:

[0128]

[0129] In the formula, For developers d j The set of neighboring nodes.

[0130] D(i m i n The calculation method for ) is as follows:

[0131]

[0132] In the formula, for Issue i n The set of neighboring nodes.

[0133] In this embodiment, by performing a preset number of feature propagation iterations and feature aggregation iterations in the node feature propagation and aggregation layers, we can obtain the feature vectors of each level of developer nodes and the feature vectors of each level of issue nodes corresponding to each issue.

[0134] Specifically, the collaborative interaction graph network of developers and issues is initialized based on the initial node feature vectors of developers and issues; the node features in the initial collaborative interaction graph network are input into the graph neural network to calculate the propagation and aggregation results of the neighboring nodes of each node; based on the propagation and aggregation results of the neighboring nodes of each node, the operation is iteratively updated to continuously obtain the high-order feature vectors of each node until the loss function tends to converge, and the final feature vectors of each node are obtained.

[0135] For low-level developer nodes, the process of generating high-level developer feature vectors based on the propagation and aggregation results is as follows:

[0136]

[0137] In the formula, For developers d j The L+1 order eigenvector, For developers d j The L-order eigenvectors, For developers d j The L-order neighbor node message aggregation uses LeakyReLU as the activation function.

[0138] The process of generating feature vectors for higher-order Issue nodes based on the propagation and aggregation results for lower-order Issue nodes is as follows:

[0139]

[0140] In the formula, for Issue i n The L+1 order eigenvector, for Issue i n The L-order eigenvectors, for Issue i n The L-order neighbor node message aggregation uses LeakyReLU as the activation function.

[0141] The loss function is as follows:

[0142]

[0143]

[0144]

[0145] In the formula, This represents the set of developer node pairs that have a cooperative relationship. C represents the set of developer node pairs that do not have a cooperative relationship, where C = C + ∪C - ; This represents a set of developer-Issue node pairs that have an interactive relationship. This represents the set of developer-Issue node pairs that do not have any interaction relationship, where I = I + ∪I - y(d j i m ) indicates developer d j and Issue i m The inner product value, y(d) j i l ) indicates developer d j and Issue i l The inner product value; This represents the set of Issue node pairs that have a similar relationship. Let S represent the set of Issue node pairs that have no similarity relationship, and S = S + ∪S - σ is a sigmoid activation function. During iterative training updates, L can be alternately optimized based on the Adam algorithm. col L int and L sim This causes the model to converge to the minimum of the sum of the three loss functions.

[0146] Step S40: Determine the inner product value between each Issue and each developer based on the feature vectors of each level of developer nodes and the feature vectors of each level of Issue nodes;

[0147] Furthermore, determining the inner product value between each Issue and each developer based on the feature vectors of developer nodes at each level and the feature vectors of Issue nodes at each level includes:

[0148] The feature vectors of each level of developer node corresponding to each developer are concatenated to obtain the feature vector of the higher-order developer node corresponding to each developer. The feature vectors of each level of issue node corresponding to each issue are concatenated to obtain the feature vector of the higher-order issue node corresponding to each issue.

[0149] The inner product between each Issue and each developer is calculated based on the feature vectors of the higher-order Issue nodes and the feature vectors of the higher-order developer nodes.

[0150] As an example, in this embodiment, the feature vectors of all developers and issues after feature aggregation and updating are obtained; in the prediction layer, the feature vectors of developers and issues nodes in different propagation layers are concatenated to obtain the final node feature vector representations of developers and issues.

[0151] The splicing process is as follows:

[0152]

[0153]

[0154] In the formula, This represents the final feature vector representation of developer d (i.e., the feature vectors of developer nodes at each level). Let || represent the final feature vector representation of Issue i (i.e., the feature vectors of each Issue node), || represent the concatenation operation, and L represent the Lth order of feature propagation.

[0155] Then, the inner product of the feature vectors of the developer and the issue is calculated. Based on the inner product result, a developer is recommended for the issue. The inner product calculation method is as follows:

[0156]

[0157] In the formula, y(d,i) represents the inner product of developer d and Issue i, and T represents the transpose operation of the feature vector, so that the column dimension of the developer feature vector is the same as the row dimension of the Issue feature vector. The size of the inner product value represents the suitability of developer d and Issue i. That is, the larger the inner product value, the more suitable the corresponding developer is to be recommended as the fixer of the Issue.

[0158] Step S50: Based on the size of the inner product, determine the top N developers from all developers as the recommended fixers for each Issue, where N is a positive integer.

[0159] As an example, in this embodiment, for a given Issue, the inner product value between each developer and the feature vector of the Issue is calculated. The inner product results are sorted from high to low, and the N developers with the highest inner product values ​​are selected as the recommended fixers for the Issue. It should be noted that the specific value of N can be determined according to actual needs.

[0160] Therefore, this embodiment fully considers the collaborative interaction relationship between developers and issues, including the cooperation relationship between developers, the interaction behavior between developers and issues, and the similarity relationship between issues. It constructs a collaborative interaction graph between developers and issues, and performs feature learning on developers and issues based on graph neural networks. It uses the inner product result of the feature vectors of developers and issues to make developer recommendations, making the recommendation results more comprehensive and accurate.

[0161] The following describes the implementation process of this application using three open-source project datasets collected from Github: React, Node.js, and npm.

[0162] We crawled all developers, issues, and issue event information from GitHub (React, Node.js, and npm) and stored them as the raw dataset. From the raw dataset, we extracted the IDs and text descriptions of all issues and used Doc2vec for feature embedding to create initial node feature vectors for each issue. We also extracted the IDs of all developers from the raw dataset and used Doc2vec for feature embedding to create initial node feature vectors for each developer. We counted the number of collaborations between developers and calculated their collaboration relationships, counted the number of interactions between developers and issues and calculated their interaction relationships, and calculated the similarity relationships between issues. We mapped the pairwise relationships between developers and issues to edges to construct the initial collaborative interaction graph network between developers and issues.

[0163] The initial feature vectors of developers and issues, along with the collaborative interaction graph, are input into the graph neural network. Based on preset node feature propagation rules and preset node feature aggregation rules, the feature vectors of developers and issues are updated through multiple feature propagation and aggregation operations until the loss function converges, at which point the updating of the feature vectors of developers and issues stops.

[0164] Finally, based on the feature vectors of the Issue and the developers learned by the graph neural network, the inner product results are calculated, and the inner product results are sorted from largest to smallest. The top N developers in the inner product results are recommended as suitable fixers for the Issue.

[0165] To demonstrate that the method proposed in this embodiment can better learn the relevant features of developers and issues from various collaborative interaction relationships, thereby achieving better recommendation results, the following comparison was conducted.

[0166] In this embodiment, the truth set of the recommendation results is the real Issue fixer data in the dataset, and the specific evaluation metrics are as follows:

[0167] Precision: The proportion of samples that are correctly predicted out of those that are recognized as true;

[0168] Recall: The proportion of true samples that can be correctly predicted out of all true samples that are predicted;

[0169] Harmonic mean F1-score: A comprehensive evaluation metric that combines precision and recall.

[0170] True Positive Rate (TPR): The proportion of predicted true samples out of all actual true samples;

[0171] False positive rate (FPR): The proportion of identified false positive samples out of all actual false samples.

[0172] Among these metrics, higher values ​​for Precision, Recall, and F1-score indicate better recommendation performance; a higher Total Recall Rate (TPR) suggests a higher probability of correct recommendations; and a higher F1-score indicates a lower error rate and better model performance. The metric calculation methods are as follows:

[0173]

[0174]

[0175]

[0176]

[0177]

[0178] In the formula, TP (True Positive) refers to a sample where the actual situation is true and the model prediction is also true; FP (False Positive) refers to a sample where the actual situation is false but the model prediction is true; FN (False Negative) refers to a sample where the actual situation is true but the model prediction is false; and TN (True Negative) refers to a sample where the actual situation is false and the model prediction is also false.

[0179] AUC: In recommendation, the output is typically a probability value, representing the probability that an issue will recommend that developer. A threshold determines whether the result is true. Adjusting the threshold yields different FPR and TPR values. Plotting these values ​​on a graph with FPR on the x-axis and TPR on the y-axis creates an ROC (receiver-roperating characteristic curve). The area under this curve is the AUC value. AUC allows observation of the overall effect of TPR and FPR; a higher AUC indicates better model performance.

[0180] This embodiment constructs a collaborative interaction graph between developers and Issues based on their interaction relationships, using this as a baseline method to observe the impact of the proposed multi-relationship method on recommendation results. Table 1 is a comparison table of the performance impact of multi-relationships in this embodiment. The data in the table shows that, for different datasets and evaluation metrics, the performance of this embodiment is significantly better than the baseline method. For example, in the React dataset, the Precision, Recall, and F1-score of this embodiment are all higher than the baseline method, and the AUC of this embodiment is 7.4% higher than the baseline method. This indicates that considering the collaborative relationships between developers and the similarity between tasks can help improve the model's recommendation performance.

[0181] Table 1 Performance Impact of Multiple Relationships

[0182]

[0183] Table 2 compares the performance of this embodiment with the benchmark methods. The benchmark methods are DeepWalk and Node2Vec. DeepWalk can effectively learn the feature representations of nodes in complex networks through random walks, and then apply them to downstream tasks such as recommendation and prediction. Node2vec is an algorithmic framework for learning continuous feature representations of nodes in a network structure. It can predict possible edges between nodes in the network and predict potentially connected developer nodes for Issue nodes. As shown in Table 2, this embodiment achieves an average accuracy between 0.743 and 0.776 and an AUC between 0.831 and 0.883 across the three datasets. Compared with other methods, this embodiment improves performance by an average of 9.24% and 19.2% in both F1-score and AUC.

[0184] Table 2 Recommended Performance Comparison Table

[0185]

[0186] Therefore, this embodiment can recommend suitable fixers for open issues based on the collaborative interaction graph between developers and issues, which is highly practical. By recommending suitable fixers, the resolution time of issues can be effectively reduced, which is beneficial to the iterative evolution of open source projects.

[0187] See Figure 3 As shown in the illustration, this application also provides an Issue Healer Recommendation Device, comprising:

[0188] The creation unit is used to set each developer and each issue as a graph node, and to create an initial node feature vector for each developer based on the developer's ID information and the ID information of its corresponding neighbor nodes, and to create an initial node feature vector for each issue based on the issue's ID information, the ID information of its corresponding neighbor nodes, and the text description content of the issue.

[0189] The building unit is used to construct a collaborative interaction graph based on the initial node feature vector of the developer, the initial node feature vector of the issue, the collaborative relationship between the developers, the interaction relationship between the issue and the developer, and the similarity relationship between the issues.

[0190] The processing unit is used to perform a preset number of feature propagation iterations and feature aggregation iterations on the developer's initial node feature vector, the issue's initial node feature vector, and the collaboration interaction graph based on preset node feature propagation rules and preset node feature aggregation rules, so as to obtain the developer node feature vectors of each level corresponding to each developer and the issue node feature vectors of each level corresponding to each issue.

[0191] The computational unit is used to determine the inner product value between each Issue and each developer based on the feature vectors of each level of developer nodes and the feature vectors of each level of Issue nodes.

[0192] The recommendation unit is used to determine the top N developers from all developers based on the size of the inner product value as the recommended fixers for each issue, where N is a positive integer.

[0193] Furthermore, the formula for calculating the collaborative relationship between the various developers is as follows:

[0194] C(d j ),d k )=α*co_inner(d j ,d k )+(1-α)*co_outer(d j ,d k )

[0195] In the formula, C(d) j ,d k ) indicates developer d j and developer d k The degree of closeness of the collaborative relationship between them, co_inner(d j ,d k This indicates that the developer d belongs to the same project as a specific issue. j and core developer d kThe number of direct collaboration relationships generated within the Issue of the project, co_outer(d j ,d k This indicates that the developer d belongs to the same project as a specific issue. j and developer d k The number of indirect collaboration relationships generated in the relevant project Issue, α∈[0,1].

[0196] Furthermore, the formula for calculating the interaction relationship between the Issue and the developer is as follows:

[0197]

[0198] In the formula, I(d) j i m ) indicates developer d j and Issue i m The degree of closeness of the interaction between them, where n represents the total number of developers, com_count(d j i m (Refers to developer d) j In Issue i m The total number of comments posted in the comments section. This indicates that all developers are targeting Issue i m The total number of comments, inter_count(d j i m ) indicates developer d j In Issue i m The number of times a certain role is played, β∈[0,1].

[0199] Furthermore, the formula for calculating the similarity relationship between the various Issues is as follows:

[0200] S(i m i n )=γ*tex_sim(i m i n )+(1-γ)*co_dev(i m i n )

[0201] In the formula, S(i m i n ) indicates Issue i m and Issue i n The degree of similarity between them, tex_sim(i m i n ) indicates Issue i m and Issue i nThe direct similarity between them, co_dev(i m i n ) indicates Issue i m and Issue i n The indirect similarity relationship between them, γ∈[0,1].

[0202] The rules for propagating the collaborative relationships among the various developers are as follows:

[0203]

[0204] In the formula, m(d) j ,d k ) indicates from developer d j and developer d k Message embedding propagation in collaborative relationships, C(d) j ,d k ) indicates developer d j and developer d k The degree of closeness of the cooperative relationship between them Indicates developer d j The developer's initial node feature vector;

[0205] The propagation rule for the interaction relationship between the developer and the Issue is as follows:

[0206]

[0207] In the formula, m(d) j i m ) indicates from developer d j and Issue i m Message embedding propagation in interaction relationships, I(d j i m ) indicates developer d j and Issue i m The degree of closeness of the interaction between them Indicates Issue i m The initial node feature vector of the Issue;

[0208] The similarity propagation rule between Issues is as follows:

[0209]

[0210] In the formula, m(i m i n ) is from Issue i m and Issue i n Message embedding propagated in similarity relationships, S(i m in ) indicates Issue i m and Issue i n The degree of similarity between them Indicates Issue i n The initial node feature vector of the Issue.

[0211] Furthermore, the preset node feature aggregation rules include aggregation rules for developer node feature messages and aggregation rules for Issue node feature messages.

[0212] The aggregation rule for the developer node feature messages is as follows:

[0213]

[0214] In the formula, Indicates developer d j message aggregation of all neighboring nodes For developers d j The set of neighboring nodes, m(d) j ,d k ) indicates from developer d j and developer d k Message embedding propagation in collaborative relationships, m(d j i m ) indicates from developer d j and Issue i m The message embedding propagated in the interaction relationship, W1 and W2 are weight matrices, D(d j ,d k ) indicates that on edge (d) j ,d k The attenuation coefficient during propagation, D(d) j i m ) indicates that on edge (d) j i m The attenuation coefficient during propagation.

[0215] The aggregation rule for the feature messages of the Issue node is as follows:

[0216]

[0217] In the formula, for Issue i m message aggregation of all neighboring nodes for Issue i m The set of neighboring nodes, m(i) m ,d j ) indicates from Issue i m and developer dj Message embedding propagation in interaction relationships, m(i m i n ) is from Issuei m and Issue i n The message embedding propagates in the similarity relationship, W3 and W4 are weight matrices, and D(i m ,d j ) indicates that on edge (i m ,d j The attenuation coefficient during propagation, D(i) m i n ) indicates that on edge (i m i n The attenuation coefficient during propagation.

[0218] Furthermore, the computing unit is specifically used for:

[0219] The feature vectors of each level of developer node corresponding to each developer are concatenated to obtain the feature vector of the higher-order developer node corresponding to each developer. The feature vectors of each level of issue node corresponding to each issue are concatenated to obtain the feature vector of the higher-order issue node corresponding to each issue.

[0220] The inner product between each Issue and each developer is calculated based on the feature vectors of the higher-order Issue nodes and the feature vectors of the higher-order developer nodes.

[0221] It should be noted that those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working process of the device and each unit described above can be referred to the corresponding process in the aforementioned Issue Repairer Recommended Embodiments, and will not be repeated here.

[0222] The apparatus provided in the above embodiments can be implemented as a computer program, which can be used in, for example... Figure 4 The Issue Repairer recommended to run on the device shown.

[0223] This application also provides an Issue Repairer Recommendation Device, comprising: a memory, a processor, and a network interface connected via a system bus, wherein the memory stores at least one instruction, and the at least one instruction is loaded and executed by the processor to implement all or part of the steps of the aforementioned Issue Repairer Recommendation Method.

[0224] The network interface is used for network communication, such as sending assigned tasks. Those skilled in the art will understand that... Figure 4The structure shown is merely a block diagram of a portion of the structure related to the present application and does not constitute a limitation on the computer device to which the present application is applied. Specific computer devices may include more or fewer components than those shown in the figure, or combine certain components, or have different component arrangements.

[0225] A processor can be a CPU, or other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components. A general-purpose processor can be a microprocessor, or any conventional processor. The processor is the control center of a computer device, connecting all parts of the computer device through various interfaces and lines.

[0226] Memory can be used to store computer programs and / or modules. The processor performs various functions of the computer device by running or executing the computer programs and / or modules stored in the memory, and by accessing data stored in the memory. Memory can primarily include a program storage area and a data storage area. The program storage area can store the operating system, application programs required for at least one function (such as video playback, image playback, etc.), etc.; the data storage area can store data created based on the use of the mobile phone (such as video data, image data, etc.). Furthermore, memory can include high-speed random access memory (RAM), and can also include non-volatile memory, such as hard disks, RAM, plug-in hard disks, SmartMedia Cards (SMC), Secure Digital Cards (SD cards), Flash Cards, at least one disk storage device, flash memory devices, or other volatile solid-state storage devices.

[0227] This application also provides a computer-readable storage medium storing a computer program thereon, which, when executed by a processor, implements all or part of the steps of the aforementioned Issue Repairer Recommendation Method.

[0228] The embodiments of this application can implement all or part of the aforementioned processes, or they can be accomplished by a computer program instructing related hardware. The computer program can be stored in a computer-readable storage medium, and when executed by a processor, it can implement the steps of the various methods described above. The computer program includes computer program code, which can be in the form of source code, object code, executable files, or certain intermediate forms. The computer-readable medium can include: any entity or device capable of carrying computer program code, recording media, USB flash drives, portable hard drives, magnetic disks, optical disks, computer memory, read-only memory (ROM), random access memory (RAM), electrical carrier signals, telecommunication signals, and software distribution media, etc. It should be noted that the content included in the computer-readable medium can be appropriately added to or subtracted according to the requirements of legislation and patent practice in the jurisdiction. For example, in some jurisdictions, according to legislation and patent practice, computer-readable media do not include electrical carrier signals and telecommunication signals.

[0229] Those skilled in the art will understand that embodiments of this application can be provided as methods, systems, servers, or computer program products. Therefore, this application can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, this application can take the form of a computer program product implemented on one or more computer-usable storage media (including, but not limited to, disk storage and optical storage) containing computer-usable program code.

[0230] This application is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of this application. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0231] It should be noted that, in this document, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or system that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or system. Unless otherwise specified, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or system that includes that element.

[0232] The above description is merely a specific embodiment of this application, enabling those skilled in the art to understand or implement this application. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of this application. Therefore, this application is not to be limited to the embodiments shown herein, but is to be accorded the widest scope consistent with the principles and novel features claimed herein.

Claims

1. A method for recommending issue fixers, characterized in that, Includes the following steps: Each developer and each issue is set as a graph node. A developer initial node feature vector is created for each developer based on the developer's ID information and the ID information of its corresponding neighbor nodes. An issue initial node feature vector is created for each issue based on the issue's ID information, the ID information of its corresponding neighbor nodes, and the text description of the issue. A collaborative interaction graph is constructed based on the initial node feature vectors of developers, the initial node feature vectors of issues, the collaborative relationships between developers, the interaction relationships between issues and developers, and the similarity relationships between issues. Based on the preset node feature propagation rules and preset node feature aggregation rules, the initial node feature vector of the developer, the initial node feature vector of the issue, and the collaborative interaction graph are subjected to a preset number of feature propagation iterations and feature aggregation iterations to obtain the developer node feature vectors of each level corresponding to each developer and the issue node feature vectors of each level corresponding to each issue. The inner product value between each Issue and each developer is determined based on the feature vectors of each level of developer nodes and the feature vectors of each level of Issue nodes. Based on the size of the inner product, the top N developers are determined from all developers as the recommended fixers for each issue, where N is a positive integer; The step of determining the inner product value between each Issue and each developer based on the feature vectors of each level of developer nodes and the feature vectors of each level of Issue nodes includes: The feature vectors of each level of developer node corresponding to each developer are concatenated to obtain the feature vector of the higher-order developer node corresponding to each developer. The feature vectors of each level of issue node corresponding to each issue are concatenated to obtain the feature vector of the higher-order issue node corresponding to each issue. The inner product between each Issue and each developer is calculated based on the feature vectors of the higher-order Issue nodes and the feature vectors of the higher-order developer nodes.

2. The Issue Repairer Recommendation Method as described in claim 1, characterized in that, The formula for calculating the collaborative relationship between the various developers is as follows: In the formula, Indicates the developer and developers The degree of closeness of the cooperative relationship between them This indicates a developer who is simultaneously affiliated with the project to which a particular issue belongs. and developers The number of direct collaboration relationships generated within the issues of the project. This indicates a developer who is simultaneously affiliated with the project to which a particular issue belongs. and developers The number of indirect collaboration relationships that occur within the project's Issue. .

3. The Issue Repairer Recommendation Method as described in claim 1, characterized in that, The formula for calculating the interaction relationship between the Issue and the developer is: In the formula, Indicates the developer and Issue The degree of closeness of the interaction between them, where n represents the total number of developers. Developers In Issue The total number of comments posted in the comments section. This indicates that all developers are addressing the Issue. Total number of comments, Indicates the developer In Issue The number of times a certain role is played. .

4. The Issue Repairer Recommendation Method as described in claim 1, characterized in that, The formula for calculating the similarity relationship between the various Issues is as follows: In the formula, Indicates Issue and Issue The degree of similarity between them Indicates Issue and Issue The direct similarity between them Indicates Issue and Issue Indirect similarity between them .

5. The Issue Repairer Recommendation Method as described in claim 1, characterized in that: The preset node feature propagation rules include the propagation rules for collaborative relationships between developers, the propagation rules for interactive relationships between developers and Issues, and the propagation rules for similarity relationships between Issues. The rules for propagating the collaborative relationships among the various developers are as follows: In the formula, This indicates that from the developer and developers Message embedding propagation in collaborative relationships Indicates the developer and developers The degree of closeness of the cooperative relationship between them Indicates the developer The developer's initial node feature vector; The propagation rule for the interaction relationship between the developer and the Issue is as follows: In the formula, This indicates that from the developer and Issue Message embedding propagation in interactive relationships Indicates the developer and Issue The degree of closeness of the interaction between them Indicates Issue The initial node feature vector of the Issue; The similarity propagation rule between Issues is as follows: In the formula, From Issue and Issue Message embedding propagation in similarity relationships, Indicates Issue and Issue The degree of similarity between them Indicates Issue The initial node feature vector of the Issue.

6. The Issue Repairer Recommendation Method as described in claim 5, characterized in that: The preset node feature aggregation rules include aggregation rules for developer node feature messages and aggregation rules for Issue node feature messages. The aggregation rule for the developer node feature messages is as follows: In the formula, Indicates the developer message aggregation of all neighboring nodes For developers The set of neighboring nodes, This indicates that from the developer and developers Message embedding propagation in collaborative relationships This indicates that from the developer and Issue Message embedding propagation in interactive relationships and It is a weight matrix. Indicates on the edge Attenuation coefficient during uppropagation Indicates on the edge Attenuation coefficient during uppropagation; The aggregation rule for the feature messages of the Issue node is as follows: In the formula, For Issue message aggregation of all neighboring nodes For Issue The set of neighboring nodes, Indicates from Issue and developers Message embedding propagation in interactive relationships From Issue and Issue Message embedding propagation in similarity relationships, and It is a weight matrix. Indicates on the edge Attenuation coefficient during uppropagation Indicates on the edge The attenuation coefficient during the upward propagation process.

7. An issue repairer recommendation device, characterized in that, include: The creation unit is used to set each developer and each issue as a graph node, and to create an initial node feature vector for each developer based on the developer's ID information and the ID information of its corresponding neighbor nodes, and to create an initial node feature vector for each issue based on the issue's ID information, the ID information of its corresponding neighbor nodes, and the text description content of the issue. The building unit is used to construct a collaborative interaction graph based on the initial node feature vector of the developer, the initial node feature vector of the issue, the collaborative relationship between the developers, the interaction relationship between the issue and the developer, and the similarity relationship between the issues. The processing unit is used to perform a preset number of feature propagation iterations and feature aggregation iterations on the developer's initial node feature vector, the issue's initial node feature vector, and the collaboration interaction graph based on preset node feature propagation rules and preset node feature aggregation rules, so as to obtain the developer node feature vectors of each level corresponding to each developer and the issue node feature vectors of each level corresponding to each issue. The computational unit is used to determine the inner product value between each Issue and each developer based on the feature vectors of each level of developer nodes and the feature vectors of each level of Issue nodes. The recommendation unit is used to determine the top N developers from all developers based on the size of the inner product value as the fixer recommendation results for each issue, where N is a positive integer; Specifically, the calculation unit is used to concatenate the feature vectors of each level of developer nodes corresponding to each developer to obtain the feature vector of each higher-order developer node corresponding to each developer; to concatenate the feature vectors of each level of issue nodes corresponding to each issue to obtain the feature vector of each higher-order issue node corresponding to each issue; and to calculate the inner product value between each issue and each developer based on the feature vectors of the higher-order issue nodes and the feature vectors of the higher-order developer nodes.

8. An Issue Repairer Recommendation Device, characterized in that, include: A memory and a processor, wherein the memory stores at least one instruction, which is loaded and executed by the processor to implement the Issue Repairer Recommended Method as described in any one of claims 1 to 6.

9. A computer-readable storage medium, characterized in that: The computer-readable storage medium stores a computer program that, when executed by a processor, implements the Issue Repairer Recommendation Method as described in any one of claims 1 to 6.

Images