Community search method for team identification in academic network

Abstract

The invention provides a community search method for team identification in an academic network, which comprises the following steps: S1, finding out a community meeting a query condition according to the query condition input by a heterogeneous academic network; s2, constructing a node set H of a target node type; s3, constructing an index HWA Index (HWA Index); s4, calculating P neighbors PN [] of the nodes in the node set H of the target node type; s5, deleting the nodes with the P neighbor number smaller than the minimum neighbor number k in the node set H of the target node type; s6, calculating the interaction strength and superposition attribute similarity between the nodes forming the P node pair in the P neighbor PN []; and S7, finding out all communities meeting the conditions and outputting the communities. According to the method, the structures and the attributes of the nodes and the interaction strength between the nodes are considered, the interaction strength and the attribute similarity of the communities are restrained through the dominating relation, and redundant search of the communities is avoided.

Description

TECHNICAL FIELD

[0001] The application belongs to the technical field of community search, and particularly relates to a community search method for team identification in an academic network. BACKGROUND

[0002] The rapid development of information technology has given birth to various complex networks, such as transportation networks, e-commerce networks, and academic networks, which describe the complex relationships between different types of entities and contain rich structural and semantic information. In these complex networks, a community is defined as a group of closely connected nodes that not only coalesce in topological structure but also exhibit high similarity in characteristics. Community search aims to find communities that meet the conditions from the network according to user query requests, thereby providing personalized services for users. In academic networks, community search technology can be used for team identification, and the core goal is to accurately locate teams that meet specific standards according to user needs. Team identification is crucial for building efficient, cohesive, and adaptable teams, and also provides convenience for users to communicate and cooperate in professional fields.

[0003] Teams in academic networks are composed of researchers. Teams composed of inexperienced researchers often exhibit less cooperation among team members, referred to as young teams, while teams composed of experienced researchers exhibit close cooperation among team members, referred to as mature teams. Due to the advantages of young teams in innovation and adaptability, and the advantages of mature teams in experience and resources, young teams and mature teams play irreplaceable roles in different application scenarios. Therefore, how to accurately identify and distinguish young teams and mature teams in academic networks through community search technology becomes particularly crucial. This distinction not only helps users to select appropriate partners according to specific needs, but also promotes the optimal allocation of resources and effective implementation of projects in the academic field.

[0004] Currently, researchers have proposed some community search technologies that can be used for team identification. For example, Wang Yixuan (invention patent CN202211008193.6) uses a pre-trained classification model to obtain user account relationship pairs with team relationships based on the user account feature information contained in the user account relationship pairs, and identifies user communities belonging to the same team from the obtained user account relationship pairs. Lin Longlong et al. (invention patent CN202410868449.3) proposed a community search technology based on subgraph conductance. This technology first samples social subgraphs from the network through breadth-first search, and then selects multiple largest groups containing the query node as the initial communities. Then, nodes that reduce the conductance of the initial communities are added to the initial communities to obtain multiple complete communities. Finally, the communities are pruned and the community with the best performance is selected as the final result. Xie Xiaoqin et al. (invention patent CN202410908392.5) disclosed a community search technology based on a k-truss nested index. This technology can efficiently build an index on the network and perform community searches based on the index to obtain communities that meet cohesive characteristics. At the same time, an index maintenance algorithm is designed to enable the index to efficiently cope with the addition and deletion of nodes and edges in the network, thereby ensuring the accuracy and real-time performance of community searches. However, these methods can only perform identification operations on networks containing a single type of nodes and relationships and cannot be applied to complex academic networks with multiple types of nodes and relationships. In complex networks, Li Yawen et al. (invention patent CN202310831630.2) disclosed a scientific research team identification method based on heterogeneous information network representation learning. Through the trained embedding representation learning model, the structural feature similarity of each node and its neighboring nodes, the first node-level attention weight of each neighboring node are obtained according to the meta-path, meta-path adjacency vector and neighboring nodes, and the second node-level attention weight is calculated from the first node-level attention weight. The person in charge, core members and non-core members of the scientific research team are determined according to the attention weights and structural feature similarities at all levels. Qiao Lianpeng et al. (Journal of Software, 2023) studied the community search problem of node attribute fairness in heterogeneous information networks. Based on -core proposed a community structure called FkPcore and proposed a maximum core mining technology based on this structure. Wang Jialong et al. (invention patent CN202410717344.8) proposed a community search method in attribute-heterogeneous information networks. This method considers both the structural and attribute information of nodes and can efficiently find community results that meet structural cohesion and attribute similarity. However, these community search technologies for complex networks ignore the interaction strength between nodes. Team identification in academic networks may result in communities containing both young and mature team members.

[0005] The deficiencies of the current community search technology mean that the existing method is challenged to accurately identify and distinguish young teams and mature teams from complex academic networks, which will directly affect the user's decision and selection. In addition, in a large-scale academic network, how to achieve fast and effective team identification is a key technical problem to be solved. SUMMARY

[0006] The objective of the embodiments of the present application is to provide a community search method for team identification in an academic network to solve the problem in the prior art that the community search does not consider the interaction strength between nodes and cannot identify and distinguish young teams and mature teams in an academic network.

[0007] To solve the above technical problems, the technical solution adopted by the present application is: a community search method for team identification in an academic network, comprising the following steps:

[0008] Step S1, according to the query condition input by the heterogeneous academic network, find out the community that meets the query condition, input the symmetric meta path and the minimum number of neighbors, and find out the community that meets the query condition from the heterogeneous academic network;

[0009] Step S2, based on the symmetric meta path from the node set get the nodes of the target node type, and form a node set H of the target node type;

[0010] Step S3, based on the node set H of the target node type and the symmetric meta path build an index HWAIndex;

[0011] Step S4, based on the index HWAIndex, calculate the neighbors PN[] of the nodes in the node set H of the target node type, for each key in the first layer of the index HWAIndex, the set skeyset formed by the corresponding second layer keys satisfies: any two nodes in the skeyset are mutual neighbors;

[0012] Step S5, delete the nodes in the node set H of the target node type whose number of neighbors is less than the minimum number of neighbors k;

[0013] Step S6, based on the index HWAIndex, calculate the interaction strength and the superposed attribute similarity between the nodes constituting the node pair in the neighbors PN[];

[0014] Step S7, based on S6, find out all communities that meet the conditions and output.

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

[0016] 1. The present application provides a community search method for team identification in academic networks, which not only considers the structure and attributes of nodes, but also considers the interaction intensity between nodes, so as to identify and distinguish young teams and mature teams in the network.

[0017] 2. The present application uses the dominance relationship to constrain the interaction intensity and attribute similarity of the community, avoiding redundant search of the community.

[0018] 3. The present application uses a bisection strategy to search the community, and uses the upper bound of the superimposed attribute similarity on this basis to reduce the problem size and greatly improve the search efficiency, saving computing resources. BRIEF DESCRIPTION OF DRAWINGS

[0019] In order to more clearly illustrate the technical solutions in the embodiments of the present application or the prior art, the drawings needed to be used in the embodiments or prior art description will be briefly introduced below. Obviously, the drawings in the following description are only some embodiments of the present application, and other drawings can also be obtained by those skilled in the art without creative labor on the basis of these drawings.

[0020] Figure 1 is a flowchart of the present application.

[0021] Figure 2 is a heterogeneous academic network graph in the present application.

[0022] Figure 3 is an index HWAIndex in the present application.

[0023] Figure 4 is a community corresponding to the interaction intensity f1=2 in the present application.

[0024] Figure 5 is a community corresponding to the Skyline vector (f1=2, f2=5 / 6) in the present application.

[0025] Figure 6 is a community corresponding to the Skyline vector (f1=1, f2=1) in the present application.

[0026] Figure 7 is the result of the effect comparison experiment in the present application.

[0027] Figure 8 is the result of the efficiency comparison experiment in the present application. DETAILED DESCRIPTION

[0028] The following will clearly and completely describe the technical solutions in the embodiments of the present invention in conjunction with the accompanying drawings. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative efforts are within the scope of protection of the present invention.

[0029] Example

[0030] The embodiment of the present invention provides a community search method for team identification in an academic network, the flow chart of which is as follows: Figure 1 As shown, the following steps are included:

[0031] Step S1: Find the communities that meet the query conditions according to the query conditions input by the heterogeneous academic network. For example, input the symmetric metapath The minimum number of neighbors k = 3, such as Figure 2 As shown in Figure 1, we find communities that meet the query conditions from a heterogeneous academic network, where A represents the author, P represents the paper, APA represents that two authors collaborate and publish a paper, and k represents the minimum number of neighbors.

[0032] The heterogeneous academic network Contains multiple node types and multiple edge types, among which, Represents a node set, v n Indicates the nth node, node The type is recorded as vertexType[v n ]; E={e1,e2,…,e m} represents the edge set, e m represents the mth edge, edge e m The type of ∈E is recorded as edgeType[e m ]; Represents a collection of attributes, nodes The attribute is recorded as attribute[v n ].

[0033] The query condition includes a symmetric metapath and the minimum number of neighbors k, where N1, N2, ..., N L+1 Indicates the node type, R1, R2, ..., R L Denotes the edge type, and L denotes the length of the meta-path. A symmetric meta-path connects nodes of the same type. It is a path structure consisting of a set of node types and edge types, describing the semantic relationship between nodes.

[0034] Figure 2The heterogeneous academic network diagram shown describes the relationship between author A, paper P, conference C and topic T. a, p, c, t represent the nodes of author, paper, conference and topic respectively. The numerical subscripts are used to distinguish different objects. The text DM (data mining), DB (database), ML (machine learning) and IR (information retrieval) next to the node describe the properties of the node. Figure 2 All communities that meet the conditions can be found, so that the nodes in any community that meets the conditions The number of neighbors is greater than or equal to the minimum number of neighbors k, and the interaction strength and superposition attribute similarity of the community are not dominated by other communities. , then the two nodes are said to be Neighbor.

[0035] Step S2: Based on symmetric element path Slave Node Set Get the nodes of the target node type to form the node set H of the target node type. For example: The target node type is author A, get the node set Each node in the set H is added to determine whether its node type is A. If it is A, the node is added to the set H until All nodes in are traversed, and finally the set H = {a1, a2, a3, a4, a5, a6, a7, a8} is obtained, where a represents the node of author A.

[0036] Step S3: Node set H based on target node type and symmetric meta-path Build the index HWAIndex. For example: H={a1,a2,a3,a4,a5,a6,a7,a8}, The constructed index HWAIndex is as follows Figure 3 As shown, the specific construction steps are as follows:

[0037] S31, take any node cur in the set H as the starting node;

[0038] S32, according to the node cur and its neighbor nodes, match If the edge type and node type in the equation are matched, the semi-long path instance hp with cur as the first node is obtained, and the tail node s, the first node cur and the path attribute Attribute(hp) of hp are added to the index HWAIndex; if the match is not found, the process jumps to S31 to obtain the next node. Among them, the semi-long path instance hp=(v1,v2,…,v L / 2+1 ), path attributes v j Indicates the jth node, attribute[vj ] represents the attribute of node v j , L represents the length of the meta-path.

[0039] As shown in Figure 3 , the index HWAIndex is a double-layer hash structure, in which the first layer key is used to store the hub node, which is the node obtained by taking cur∈H as the starting node and following the meta-path , the node type of which is N L / 2+1 , and is also the tail node of the half-length path instance; the second layer key is used to store the starting node cur, and the second layer value is a sequential table, which stores the attributes contained in the path from the target type node to the hub node, and if there are multiple paths, multiple path attributes are stored. In the hash structure, the key represents an identifier uniquely identifying a value or a group of values, and the value represents the corresponding value obtained according to the key.

[0040] For example: in S31, cur=a1∈H={a1,a2,a3,a4,a5,a6,a7,a8}, then S32 can match the half-length path instances (a1,p1), (a1,p2), (a1,p5), (a1,p6), and add the tail node, head node and path attribute of each half-length path instance to HWAIndex; then continue to execute S31 to obtain the next node and repeat the above operation until all nodes in the set H are traversed, and finally obtain the index HWAIndex as shown in Figure 3 .

[0041] Step S4, based on the index HWAIndex, calculate the neighbors PN[] of the nodes in the node set H of the target node type, for each key of the first layer of the index HWAIndex, the set skeyset composed of the corresponding second layer key satisfies: any two nodes in skeyset are neighbors. Therefore, the neighbors of each node can be directly obtained through skeyset.

[0042] For example: key=p1, a1,a2 can be obtained as neighbors; key=p2, a1,a2,a3 can be obtained as neighbors; and so on, finally obtaining the neighbors of each target type node.Neighbours: PN[a1] = {a2, a3, a4}, PN[a2] = {a1, a3, a4}, PN[a3] = {a1, a2, a4}, PN[a4] = {a1, a2, a3, a5, a6, a7, a8}, PN[a5] = {a4, a6, a7, a8}, PN[a6] = {a4, a5, a7, a8}, PN[a7] = {a4, a5, a6, a8}, PN[a8] = {a4, a5, a6, a7}.

[0043] Step S5, deleting nodes in the node set H of the target node type whose number of neighbours is less than the minimum number of neighbours k, and the H after the deletion is denoted as set H', and the specific steps are as follows:

[0044] S51, obtaining the number of neighbours PN[u] of the target type node u e H, and if the number of nodes in PN[u] is less than the minimum number of neighbours k, adding the node u to the queue Queue until all nodes in H are traversed; if the queue Queue is not empty, entering step S52, otherwise entering step S6;

[0045] S52, obtaining the head node q in the queue Queue;

[0046] S53, obtaining the number of neighbours PN[nb] of the neighbour node nb of q, and deleting q from PN[nb];

[0047] S54, if the number of nodes in PN[nb] is less than the minimum number of neighbours k, adding the neighbour node nb of q to the queue Queue;

[0048] S55, deleting PN[q] from PN[].

[0049] For example, taking set H = {a1, a2, a3, a4, a5, a6, a7, a8} and the minimum number of neighbours k = 3, first obtaining the target type node u = a1 e H, since the number of nodes |PN[a1]| = 3 > k = 3 in PN[a1] = {a2, a3, a4}, the neighbours of a1 satisfy the condition; continue to obtain the next node u = a2 e H, since the number of nodes |PN[a2]| = 3 > k = 3 in PN[a2] = {a1, a3, a4}, the neighbours of a2 satisfy the condition; and so on until all nodes in H are traversed. Since the number of neighbours of all nodes in H is greater than or equal to k = 3, the Queue obtained is empty, and the neighbours PN[] of the nodes in set H remain unchanged.

[0050] ​​​​​​​Step S6, based on the index HWAIndex, calculate constituted by the neighbors PN[] The interaction strength and the superposition attribute similarity between the nodes of the node pair (if two nodes satisfy the neighbor relationship, the two nodes constitute a node pair) are stored in the array NIntStr[] and the array LapASim[], and the specific steps are as follows:

[0051] S61, based on S5, remove the set H' obtained by the nodes whose number of neighbors is less than the minimum number of neighbors k, obtain the node pair pair(x, y) constituted by any node x∈H' and its neighbor y∈PN[x], and store it in NIntStr[] and LapASim[], and then initialize NIntStr[pair(x, y)]=0, LapASim[pair(x, y)]=0 (in order to avoid repeated calculation, so that the serial number of x is less than y), until all nodes in the set H' are traversed;

[0052] S62, obtain the first layer key, key∈HWAIndex.getFKeySet(), wherein getFKeySet() represents a method for obtaining the set of the first layer keys in the hash structure, and HWAIndex represents the index;

[0053] S63, obtain the set of the second layer keys through HWAIndex.get(key).getSKeySet(), and obtain the nodes x and y belonging to HWAIndex.get(key).getSKeySet(), wherein get(key) represents a method for obtaining the value corresponding to the key, getSKeySet() represents a method for obtaining the set of the second layer keys in the hash structure, and HWAIndex represents the index;

[0054] S64, judge whether the node pair pair(x, y) (x is less than y in serial number) constituted by x and y exists in the array NIntStr[] and the array LapASim[], if it exists, go to step S65, otherwise jump to step S63;

[0055] S65, obtain the order table xlist and ylist, and calculate the interaction strength and the superposition attribute similarity of the node pair pair(x, y) according to xlist and ylist, and the specific formula is as follows:

[0056] ​​​xlist = HWAIndex.get(key).get(x)

[0057] ylist = HWAIndex.get(key).get(y)

[0058] NIntStr[pair(x, y)] = NIntStr[pair(x, y)] + xlist.size() * ylist.size()

[0059]

[0060] wherein pair(x, y) represents a node pair, NIntStr[pair(x, y)] represents the interaction strength of the node pair, LapASim[pair(x, y)] represents the superimposed attribute similarity of the node pair, xlist and ylist are sequential tables storing path attributes, xlist.size() and ylist.size() represent the length of the sequential table, and xset and yset represent the elements of the sequential table, i.e., path attributes.

[0061] For example, take H' = {a1, a2, a3, a4, a5, a6, a7, a8} as an example:

[0062] S61, get x = a1 e H' and its neighbors y e PN[a1] = {a2, a3, a4} to form node pairs pair(a1, a2), pair(a1, a3), and pair(a1, a4), which are stored in NIntStr[] and LapASim[] and initialized, so that NIntStr[pair(a1, a2)] = 0, LapASim[pair(a1, a2)] = 0, NIntStr[pair(a1, a3)] = 0, LapASim[pair(a1, a3)] = 0, NIntStr[pair(a1, a4)] = 0, and LapASim[pair(a1, a4)] = 0; subsequent operations are similar, until all nodes in H' are traversed;

[0063] S62, get key = p1 e HWAIndex.getFKeySet() = {p1, p2, p3, p4, p5, p6, p7};

[0064] S63, get nodes x = a1, y = a2 e HWAIndex.get(p1).getSKeySet() = {a1, a2};

[0065] S64, since pair (a1, a2) exists in NIntStr[] and LapASim[], enter S65;

[0066] S65, obtain the sequence list xlist = HWAIndex.get(p1).get(a1) = [{DM, IR}], ylist = HWAIndex.get(p1).get(a2) = [{DM, ML}], where DM (data mining), IR (information retrieval), and ML (machine learning) represent the attribute values ​​describing the nodes, and calculate the current NIntStr[pair(a1, a2)] = NIntStr[pair(a1, a2)] + 1 = 0 + 1 = 1, LapASim[pair(a1, a2)] = LapASim[pair(a1, a2)] + 1 / 3 = 0 + 1 / 3 = 1 / 3 according to the formula; then continue to execute S62 until all keys are traversed, and finally obtain the interaction strength and superposition attribute similarity as shown in Table 1:

[0067] Table 1 Inter-node interaction strength and superposition attribute similarity of node pairs

[0068]

[0069]

[0070] S7. Based on the interaction strength array NIntStr[] and the superposition attribute similarity array LapASim[] obtained in S6, find all communities that meet the conditions and output them. The specific steps are as follows:

[0071] S71, based on NIntStr[], uses bucket sorting Node pairs are sorted in ascending order, that is, nodes with the same interaction strength value are sorted in ascending order. The node pairs are placed in the same bucket, and different buckets are arranged in ascending order according to the interaction strength value. Let StrBucket() = [strb1, strb2, ..., strb l1 ], where StrBucket() represents a sequence of buckets sorted in ascending order of interaction strength values, strb represents a bucket in StrBucket(), and l1 represents the length of StrBucket();

[0072] S72, obtaining the minimum interaction strength value minf1 from StrBucket(), and setting f1 = ∞, f2 = 0, where StrBucket() represents a sequence of buckets arranged in ascending order of interaction strength values, f1 represents the interaction strength value of the community, and f2 represents the superposition attribute similarity value of the community;

[0073] S73, determine whether the community's interaction strength value f1 is greater than the minimum interaction strength value minf1 obtained from StrBucket(), if so, enter the loop steps S74 to S712, otherwise enter step S713;

[0074] S74, store the buckets in StrBucket() into the temporary bucket sequence Bucket1(), and delete from Bucket1() the buckets whose interaction strength value is less than minf1 or whose superposition attribute similarity value is less than f2. For a node pair, let left = 1, right = |Bucket1()| (left and right are used to mark the left and right subscripts of the bucket sequence currently to be processed, respectively, and |Bucket1()| represents the number of buckets). Determine whether left is equal to right. If so, obtain the interaction strength value corresponding to Bucket1 (left) and assign it to f1, and proceed to step S76. Otherwise, proceed to step S75.

[0075] S75, set two empty sets N = {} and E = {}, based on Bucket1() and its left subscript left and right subscript right, calculate the index value f through the public operation CS and assign it to f1, E represents the storage A collection of node pairs, N represents the storage structure A collection of nodes that are pairs of nodes;

[0076] S76, obtain the subgraph corresponding to the community's interaction strength value f1, and the subgraph in StrBucket() whose interaction strength value is equal to f1 The set of node pairs PairSet, and then find the nodes contained in the subgraph from PairSet The maximum superposition attribute similarity value upf2 of the node pair;

[0077] S77, based on the superposition attribute similarity LapASim[], sort the subgraph by bucket sorting Node pairs are sorted in ascending order, that is, nodes with the same superposition attribute similarity values ​​are sorted. The nodes are placed in the same bucket, and different buckets are arranged in ascending order according to the superposition attribute similarity value. Let SimBucket() = [simb1,simb2,…,simb l2 ], where SimBucket() represents a sequence of buckets sorted in ascending order of superimposed attribute similarity values, simb represents a bucket in SimBucket(), and l2 represents the length of SimBucket();

[0078] S78, let N and E be empty;

[0079] S79, store the buckets of SimBucket() in S77 into a temporary bucket sequence Bucket2(), and delete the buckets in Bucket2() greater than the maximum overlay attribute similarity value upf2 in S78; S80, add the node pair to E, and add the corresponding nodes to N, while deleting the buckets in Bucket2() greater than upf2; S81, let left = 1, right = |Bucket2()| (left and right are used to mark the left index and right index of the bucket sequence currently to be processed, respectively, and |Bucket2()| represents the number of buckets arranged in ascending order of overlay attribute similarity value), judge whether left is equal to right, if yes, let f2 = upf2, and enter step S711, otherwise enter step S710;

[0080] S710, based on Bucket2() and its left index left and right index right, calculate the index value f by common operation CS and assign it to f2;

[0081] S711, store the Skyline vector (f1, f2) and its corresponding community result;

[0082] S712, find the minimum overlay attribute similarity value greater than f2 from LapASim[], assign it to f2, and jump to step S73;

[0083] S713, output all communities satisfying the condition and the corresponding Skyline vector.

[0084] For example: S71, get the sorted result StrBucket() based on NIntStr[] as shown in Table 2;

[0085] Table 2 Get the sorted result based on NIntStr[]

[0086]

[0087]

[0088] S72, minf1 = 1, f1 = ∞, f2 = 0;

[0089] S73, f1 is greater than minf1, enter loop steps S74-S712;

[0090] S74, Bucketl() = [{pair(a4,a5), pair(a4,a6), pair(a4,a7), pair(a4,a8), pair(a5,a6), pair(a5,a7), pair(a5,a8), pair(a6,a7), pair(a6,a8), pair(a7,a8)},{pair(a1,a3), pair(a1,a4), pair(a2,a3), pair(a2,a4)},{pair(a1,a2), pair(a3,a4)}], left = 1, right = 3, since left is not equal to right, go to step S75;

[0091] S75, calculate f1 = 2;

[0092] S76, get the subgraph corresponding to f1 = 2, as shown in Figure 4 , get PairSet = {pair(a1,a3), pair(a1,a4), pair(a2,a3), pair(a2,a4)}; find the maximum overlay attribute similarity value upf2 = 2 of the node pairs contained in the subgraph from PairSet;

[0093] S77, get the sorted result SimBucket() based on LapASim[] as shown in Table 3;

[0094] Table 3 Sorted result based on LapASim[]

[0095]

[0096] S78, let N and E be empty;

[0097] S79, Bucket2() = [{pair(a1,a4), pair(a2,a3)},{pair(a3,a4)},{pair(a1,a2)},{pair(a1,a3), pair(a2,a4)}]; left = 1, right = 4, since left is not equal to right, go to step S710;

[0098] S710, calculate f2 = 5 / 6;

[0099] S711, store the Skyline vector (f1 = 2, f2 = 5 / 6) and its corresponding subgraph {a1, a2, a3, a4}, as shown in Figure 5 ;

[0100] ​S712, find the minimum overlay attribute similarity value greater than f2=5 / 6 from LapASim[], assign f2 to get f2=1, and jump to step S73 to continue the similar operation;

[0101] S713, finally output all the subgraphs satisfying the condition {{a1, a2, a3, a4}, {a5, a6, a7, a8}} and its Skyline vector {(2, 5 / 6), (1, 1)}, and the result is shown in Figures 5-6 Figure 5 The interaction intensity of the subgraph shown in Figure 6 is greater, the cooperation between the authors is closer, and it is considered as a mature team, while the interaction intensity of the subgraph shown in

[0102] Public operation CS: calculate the index value f according to the bucket sequence Bucket() and its left index left and right index right, wherein Bucket() represents temporary bucket sequence Bucket1() or Bucket2(), and f represents interaction intensity value f1 or overlay attribute similarity value f2.

[0103] CS1, judge whether left is less than right, if yes, enter the loop steps CS2-CS9, otherwise, jump out of the current loop and enter CS10;

[0104] CS2, if left is less than or equal to right (in the inner loop, left and right will change, so the inner loop needs to ensure that left is less than or equal to right), enter the loop steps CS3-CS5, otherwise, enter step CS6;

[0105] CS3, let mid=(left+right) / 2, mid is used to mark the middle index of the current bucket sequence to be processed; add the node pairs in the bucket Bucket(b) (mid≤b≤right) to E, and add the corresponding nodes to N, b represents the sequence number of the bucket; assign N and E to temporary variables N' and E' respectively; delete the nodes with less than k neighbors from N' and update E'; find all connected subgraphs from E' to get GSet, GSet represents the set of connected subgraphs;

[0106] ​CS4, determine whether GSet is empty, if empty then right = mid - 1, and jump to step CS2, otherwise enter step CS5;

[0107] CS5, left = mid, get the index value corresponding to Bucket(mid) and assign it to f, store the subgraph in the GSet corresponding to f, and jump out of the loop corresponding to step CS2, enter step CS6;

[0108] CS6, if left is less than or equal to right, then enter the loop steps CS7-CS9, otherwise jump to step CS1;

[0109] CS7, mid = (left + right) / 2, delete the node pairs existing in the bucket Bucket(b) (left ≤ b ≤ mid) from E, update the corresponding nodes in N, assign N and E to temporary variables N' and E' respectively, b represents the serial number of the bucket, then delete the nodes with less than k neighbors from N' and update E', find all connected subgraphs from E' to get GSet;

[0110] CS8, determine whether GSet is empty, if empty then right = mid, and jump out of the loop corresponding to step CS6, and jump to step CS1, otherwise enter step CS9;

[0111] CS9, left = mid + 1, get the index value corresponding to Bucket(mid + 1) and assign it to f, store the subgraph in the GSet corresponding to f, and jump to step CS6;

[0112] CS10, return the index value f and its corresponding subgraph.

[0113] For example: when Bucket1() = [{pair(a4,a5), pair(a4,a6), pair(a4,a7), pair(a4,a8), pair(a5,a6), pair(a5,a7), pair(a5,a8), pair(a6,a7), pair(a6,a8), pair(a7,a8)},{pair(a1,a3), pair(a1,a4), pair(a2,a3), pair(a2,a4)},{pair(a1,a2), pair(a3,a4)}] is obtained in S74, left = 1, right = 3, then the common operation CS is executed, at this time Bucket() = Bucket1(), left = 1, right = 3.

[0114] ​​In CS1, left is less than right, and the loop of CS2-CS9 is entered; in CS2, left is less than right, and the loop of CS3-CS5 is entered; in CS3, mid=(left+right) / 2=2, E={pair(a1,a2), pair(a1,a3), pair(a1,a4), pair(a2,a3), pair(a2,a4), pair(a3,a4)}, N={a1, a2, a3, a4}, E'={pair(a1,a2), pair(a1,a3), pair(a1,a4), pair(a2,a3), pair(a2,a4), pair(a3,a4)}, N'={a1, a2, a3, a4}, and the following is deleted In CS4, since GSet is not empty, CS5 is entered; in CS5, left=mid=2, f=2, the subgraph {a1, a2, a3, a4} corresponding to f=2 is stored, the loop of CS2 is exited, and CS6 is entered; in CS6, left is less than right, and the loop of CS7-CS9 is entered; in CS7, mid=(left+right) / 2=2, E={pair(a1,a2), pair(a3,a4)}, N={a1, a2, a3, a4}, E'={pair(a1,a2), pair(a3,a4)}, N'={a1, a2, a3, a4}, and the following is deleted In CS8, since GSet is empty, right=mid=2, the loop of CS6 is exited, and CS1 is entered;

[0115] In CS1, left is not less than right, and the current loop is exited; in CS10, the index value f=2 is returned.

[0116] The index value f=2 obtained by the example of the above common operation CS is the calculation process of the example S75 in S7, and other parts of the operation of calling the common operation CS are similar.

[0117] The application effectively distinguishes the structural feature difference between young teams and mature teams by introducing the interaction strength between nodes on the basis of considering the structure and attributes of the nodes, and uses the dominance relation to constrain the interaction strength and attribute similarity of the community, so that the accuracy and efficiency of the community search are improved in the search process, the deficiencies of the prior art in team feature recognition are made up, the search performance is optimized, and the application has academic value and application prospect.

[0118] Experimental verification

[0119] The DBLP dataset (data source: https: / / dblp.uni-trier.de / xml / .) is used for comparative experiments, which contains 37791 nodes, 341588 edges, 32383 attribute values, 4 node types and 6 edge types. In order to conduct experiments, 12 meta-paths with a length of no more than 4 are generated, and the positive integer k is set to 10 by default. The experimental results are as follows:

[0120] Effect comparison: in the experiment, each of the 12 meta-paths is taken out to form a query condition together with the positive integer k = 10, and then the query condition is input into the method of the search -core (comparative method 1), the method of only considering the interaction intensity (comparative method 2) and the method of the present application, thereby obtaining the community search results of the three methods, and then the PathSim value of the community results is calculated. The average PathSim value of the results of 12 groups of comparative experiments is shown in Table 2, and the results show that the PathSim value of the community results obtained by the present application is larger, indicating that the community searched by the present application has greater similarity. Figure 7

[0121] Efficiency comparison: in the experiment, based on the above 12 query conditions, the average execution time of the method using the superimposed attribute similarity upper bound and the method not using the superimposed attribute similarity upper bound is compared by changing the positive integer k, and the experimental results are shown in Table 3. The experimental results show that the execution efficiency of the method using the superimposed attribute similarity upper bound is always higher than that of the method not using the superimposed attribute similarity upper bound, proving that the superimposed attribute similarity upper bound is effective in improving efficiency. In addition, the experimental results also show that the change of the positive integer k has little effect on the two search methods. Figure 8

[0122] Each embodiment in the specification is described in a related manner, and the same or similar parts between each embodiment can be referred to each other. Each embodiment mainly explains the difference from other embodiments. Especially, for the system embodiment, since it is basically similar to the method embodiment, the description is relatively simple, and the related parts can be referred to the part of the method embodiment.

[0123] The above only describes the preferred embodiments of the present application and is not used to limit the protection scope of the present application. Any modification, equivalent replacement, improvement, etc. made within the spirit and principles of the present application shall be included in the protection scope of the present application.​​

Claims

1. A community search method for team identification in an academic network, characterized by the following steps: include: Step S1, according to the query conditions input into the heterogeneous academic network, find the communities that meet the query conditions; Step S2: Based on S1, construct a node set H of the target node type; Step S3, constructing the index HWAIndex; Step S4, calculate the nodes in the node set H of the target node type Neighbor PN[]; Step S5: Delete the node set H of the target node type. Nodes whose number of neighbors is less than the minimum number of neighbors k; Step S6, calculate Neighbor PN[] Interaction strength and superposition attribute similarity between node pairs; Step S7: Based on S6, find all communities that meet the conditions and output them.

2. A community search method for team identification in an academic network according to claim 1, characterized in that: The heterogeneous academic network described in S1 Contains multiple node types and multiple edge types, among which, Represents a node set, v n Indicates the nth node, node The type is recorded as vertexType[v n ]; E={e1,e2,…,e m } represents the edge set, e m represents the mth edge, edge e m The type of ∈E is denoted as edgeType[e m ]; Represents a collection of attributes, nodes The attribute is recorded as attribute[v n ]; The query condition includes a symmetric metapath and the minimum number of neighbors k, where N1, N2, ..., N L+1 Indicates the node type, R1, R2, ..., R L Indicates the edge type, and L indicates the length of the meta-path.

3. A community search method for team identification in an academic network according to claim 1, characterized in that: The specific steps of S3 are as follows: S31, take any node cur in the set H as the starting node; S32, according to the node cur and its neighbor nodes, match If the edge type and node type in the are matched, the semi-long path instance hp with cur as the first node is obtained, and the tail node s, the first node cur and the path attribute Attribute(hp) of hp are added to the index HWAIndex; if the match is not found, the process jumps to S31 to obtain the next node; wherein, the semi-long path instance hp=(v1,v2,…,v L / 2+1 ), path attributes v j Indicates the jth node, attribute[v j ] represents node v j , L represents the length of the meta-path.

4. A community search method for team identification in an academic network according to claim 1, characterized in that: In S4, for each key in the first layer of the index HWAIndex, the set skeyset of its corresponding second layer keys satisfies: any two nodes in skeyset are mutually Neighbor.

5. The community search method for team identification in an academic network according to claim 1, characterized in that: The specific steps of S5 are as follows: S51, obtain the target type node u∈H Neighbor PN[u], if the number of nodes in PN[u] is less than the minimum number of neighbors k, then add node u to the queue Queue until all nodes in H are traversed; If the queue Queue is not empty, go to step S52, otherwise go to step S6; S52, obtaining the head node q in the queue Queue; S53, obtain the neighbor node nb of q Neighbor PN[nb], and delete q from it; S54, if the number of nodes in PN[nb] is less than the minimum number of neighbors k, then add the neighbor node nb of q to the queue Queue; S55, delete PN[q] from PN[].

6. A community search method for team identification in an academic network according to claim 1, characterized in that: The specific steps of S6 are as follows: S61, based on the set H' obtained in S5, obtain any node x∈H' and its Neighbors y∈PN[x] Node pair pair (x, y) is stored in NIntStr[] and LapASim[], and then NIntStr[pair(x, y)] = 0 and LapASim[pair(x, y)] = 0 are initialized until all nodes in the set H' are traversed; S62, obtaining the first-layer key, key∈HWAIndex.getFKeySet(), where getFKeySet() represents a method for obtaining a set of first-layer keys in a hash structure, and HWAIndex represents an index; S63, obtain the set of second-layer keys through HWAIndex.get(key).getSKeySet(), and obtain that both nodes x and y belong to HWAIndex.get(key).getSKeySet(), where get(key) represents a method for obtaining the value corresponding to the key, getSKeySet() represents a method for obtaining the set of second-layer keys in the hash structure, and HWAIndex represents an index; S64, determine whether there is a sequence consisting of x and y in the arrays NIntStr[] and LapASim[] If the node pair (x, y) exists, go to step S65, otherwise jump to step S63; S65, obtain the sequence lists xlist and ylist, and calculate based on xlist and ylist The interaction strength and superposition attribute similarity of node pair (x, y) are as follows: xlist=HWAIndex.get(key).get(x) ylist=HWAIndex.get(key).get(y) NIntStr[pair(x,y)]=NIntStr[pair(x,y)]+xlist.size()×ylist.size() Among them, pair (x, y) represents For a node pair, NIntStr[pair(x,y)] represents the interaction strength of the node pair, LapASim[pair(x,y)] represents the superposition attribute similarity of the node pair, xlist and ylist are sequence lists that store path attributes, xlist.size() and ylist.size() represent the length of the sequence list, and xset and yset represent the elements of the sequence list, i.e., the path attributes.

7. A community search method for team identification in an academic network according to claim 1, characterized in that: The specific steps of S7 are as follows: S71, based on NIntStr[], use bucket sorting to sort the P node pairs in ascending order, that is, put the P node pairs with the same interaction strength value in the same bucket, and sort different buckets in ascending order according to the interaction strength value, let StrBucket() = [strb1, strb2, ..., strb l1 ], where StrBucket() represents a sequence of buckets sorted in ascending order of interaction strength values, strb represents a bucket in StrBucket(), and l1 represents the length of StrBucket(); S72, obtaining the minimum interaction strength value minf1 from StrBucket(), and setting f1 = ∞, f2 = 0, where StrBucket() represents a sequence of buckets arranged in ascending order of interaction strength values, f1 represents the interaction strength value of the community, and f2 represents the superposition attribute similarity value of the community; S73, determine whether the community's interaction strength value f1 is greater than the minimum interaction strength value minf1 obtained from StrBucket(), if so, enter the loop steps S74 to S712, otherwise enter step S713; S74: Store the buckets in StrBucket() into a temporary bucket sequence Bucket1(), and delete from Bucket1() the P node pairs whose interaction strength values ​​are less than minf1 or whose superposition attribute similarity values ​​are less than f2. Set left = 1, right = |Bucket1()|, where left and right are used to mark the left and right subscripts of the bucket sequence currently to be processed, respectively, and |Bucket1()| represents the number of buckets. Determine whether left is equal to right. If so, obtain the interaction strength value corresponding to Bucket1(left) and assign it to f1, and proceed to step S76; otherwise, proceed to step S75. S75, set two empty sets N = {} and E = {}, calculate the index value f based on Bucket1() and its left subscript left and right subscript right through the common operation CS and assign it to f1, E represents the set storing P node pairs, and N represents the set storing the nodes constituting the P node pairs; S76, obtaining the subgraph corresponding to the community's interaction strength value f1 and the set PairSet consisting of the P node pairs with the same interaction strength value as f1 in StrBucket(), and then finding the maximum superposition attribute similarity value upf2 of the P node pairs contained in the subgraph from PairSet; S77, based on the superposition attribute similarity LapASim[], the P node pairs in the subgraph are arranged in ascending order by bucket sorting, that is, the P node pairs with the same superposition attribute similarity value are placed in the same bucket, and different buckets are arranged in ascending order according to the superposition attribute similarity value, let SimBucket() = [simb1,simb2,…,simb l2 ], where SimBucket() represents a sequence of buckets sorted in ascending order of superimposed attribute similarity values, simb represents a bucket in SimBucket(), and l2 represents the length of SimBucket(); S78, let N and E be empty; S79, store the bucket of SimBucket() in S77 into the temporary bucket sequence Bucket2(), and add the P node pairs in Bucket2() that are greater than the maximum superposition attribute similarity value upf2 to E, add the corresponding nodes to N, and delete the P node pairs in Bucket2() that are greater than upf2; let left = 1, right = |Bucket2()|, where left and right are used to mark the left subscript and right subscript of the bucket sequence currently to be processed, respectively, and |Bucket2()| represents the number of buckets arranged in ascending order of superposition attribute similarity value. Determine whether left is equal to right. If so, set f2 = upf2 and go to step S711, otherwise go to step S710; S710, based on Bucket2() and its left subscript left and right subscript right, calculate the index value f through the common operation CS and assign it to f2; S711, store the skyline vector (f1, f2) and its corresponding community result; S712, find the minimum superposition attribute similarity value greater than f2 from LapASim[] and assign it to f2, and jump to step S73; S713: Output all communities that meet the conditions and their corresponding skyline vectors.

8. A community search method for team identification in an academic network according to claim 7, characterized in that: The public operations CS described in S7 are as follows: CS1, determines whether left is less than right. If so, it enters loop steps CS2 to CS9. Otherwise, it exits the current loop and enters CS10. CS2, if left is less than or equal to right, then go into loop steps CS3 to CS5, otherwise go into step CS6; CS3, let mid = (left + right) / 2, where mid is used to mark the middle subscript of the bucket sequence currently being processed; add the P node pair in bucket (b) to E, and at the same time add the corresponding node to N, where b represents the bucket number and mid ≤ b ≤ right; assign N and E to temporary variables N' and E', respectively; delete nodes with fewer than k P neighbors from N' and update E'; find all connected subgraphs from E' to obtain GSet, which represents the set of connected subgraphs; CS4, determine whether GSet is empty. If it is empty, set right = mid - 1 and jump to step CS2, otherwise go to step CS5; CS5, set left = mid, get the index value corresponding to Bucket (mid) and assign it to f, store the subgraph in GSet corresponding to f, and jump out of the loop corresponding to step CS2 and enter step CS6; CS6, if left is less than or equal to right, then go to loop steps CS7 to CS9, otherwise jump to step CS1; CS7, let mid = (left + right) / 2, delete the P node pairs in bucket (b) from E, and update the corresponding nodes in N, where b represents the bucket index, left ≤ b ≤ mid; assign N and E to temporary variables N' and E' respectively, then delete the nodes with fewer than k P neighbors from N' and update E'; find all connected subgraphs from E' to obtain GSet; CS8, determine whether GSet is empty. If it is empty, set right = mid, jump out of the loop corresponding to step CS6, and jump to step CS1, otherwise go to step CS9; CS9, set left = mid + 1, get the index value corresponding to Bucket (mid + 1) and assign it to f, store the subgraph in GSet corresponding to f, and jump to step CS6; CS10, returns the index value f and its corresponding subgraph.

Images