A k-core subgraph maximization method and system satisfying nuclear value and budget constraint

Abstract

This invention provides a method and system for maximizing k-core subgraphs while satisfying kernel value and budget constraints. The method involves preprocessing graph data and constructing an onion-layer structure; filtering candidate sets; calculating k-core Followers; and maintaining the onion-layer structure. This invention analyzes the structural changes caused by the "vertex merging" operation, thereby reducing time overhead. By designing a candidate set strategy based on Core-Adjacent Vertices and an adaptive strategy, it addresses situations where effective results cannot be calculated under extreme conditions, such as when the budget value or the target kernel value is too large. This invention outperforms existing methods in terms of both runtime and the number of valid results calculated, demonstrating strong applicability and significant effectiveness.

Description

Technical Field

[0001] This invention relates to the field of graph data mining technology, and in particular to a method and system for maximizing k-core subgraphs that satisfy kernel value and budget constraints. Background Technology

[0002] Graphs, as a powerful tool, are widely used in scenarios such as social networks and transportation networks. With the widespread application of graphs, their size and structural complexity continue to grow. How to efficiently analyze and optimize the structure of large-scale graphs has become an important issue in the field of graph computing. Against this backdrop, subgraph maximization has emerged as a focus in recent years, aiming to expand the size of a target subgraph satisfying specific constraints as much as possible by manipulating the graph structure. In social networks, subgraphs represent the connection structure between users. By appropriately establishing connections and structural relationships between users, it can be used to discover potential friend relationships and build recommendation systems, or to identify high-quality users to form teams. In aviation networks, subgraphs represent the reachability structure of airports and routes. Expanding the size of subgraphs by adding connections helps improve network connectivity and overall reachability between airports.

[0003] The k-core model, as a cohesive subgraph model that efficiently describes the relationships between vertices, is widely used in the subgraph maximization problem. A k-core subgraph is defined as the maximally induced subgraph in a graph that satisfies the condition that "each vertex has at least k neighbors," where no vertex in the k-core subgraph has a coreness of k with any vertex in the (k+1)-core subgraph. Correspondingly, the k-core subgraph maximization problem focuses on maximizing the vertex size of a given k-core subgraph through structural adjustments under given budget and constraints. Existing work on the k-core subgraph maximization problem mainly focuses on three typical strategies: 1) Edge insertion: strengthening local support relationships by adding connections to the network, making more vertices satisfy the k-core degree constraint; 2) Vertex anchoring: selecting a certain number of vertices to be forcibly retained, thereby improving the coreness of surrounding vertices; 3) Vertex merging: merging some vertices pairwise to induce local structural reconstruction, thereby aiming to increase the size of the k-core subgraph.

[0004] Compared to edge insertion and vertex anchoring, research on k-core subgraph maximization based on vertex merging is still relatively insufficient: on the one hand, merging operations change adjacency relationships and have a chain reaction effect on subgraph structure, making candidate set selection and impact assessment more complex; on the other hand, on large-scale graphs, it is necessary to balance computational efficiency and performance improvement, and existing methods are difficult to meet the requirements of "fast" and "high benefit" at the same time.

[0005] Currently, there is still relatively little research on "k-core subgraph maximization based on vertex merging strategy". Existing methods are as follows: given an integer k∈Z+, budget b∈Z+, divide the vertices into core vertices (coreness = k) according to the coreness of the vertex. and Then, the six merging strategies generated by the three types of vertices were analyzed: out-out, out-shell, out-core, shell-shell, shell-core, and core-core. It was found that among the six merging strategies, the core-core merging strategy could not increase the coreness of any vertex to k. The effects of the out-core and shell-core merging strategies, i.e., the number of vertices whose coreness increased to k, were less than the other three strategies. Finally, using out vertices and shell vertices as candidate sets, at most b rounds of simulated merging were conducted based on the three merging strategies to find at most b pairs of vertex pairs that maximized the size of the k-core subgraph and the (k-1)-core subgraph after each round of simulated merging.

[0006] However, existing research suffers from three unavoidable problems: 1) Overall operational efficiency is low, with time overhead increasing rapidly with graph size (number of vertices / edges). 2) It is difficult to accurately characterize the cascading effects of "vertex merging" on the global structure. 3) The algorithm may fail to produce effective results under certain graph structures or parameter conditions.

[0007] Therefore, it is necessary to further study vertex merging strategies for k-core models, design an algorithmic framework that can efficiently search for merging pairs on large graphs and effectively promote k-core expansion, and provide a more practical solution for related network optimization applications. Summary of the Invention

[0008] The purpose of this invention is to provide a method and system for maximizing k-core subgraphs that satisfies kernel value and budget constraints.

[0009] A method for maximizing a k-core subgraph that satisfies kernel value and budget constraints includes the following steps:

[0010] S1: Preprocess the graph data and construct the onion layer structure;

[0011] S2: Filter the candidate set;

[0012] S3: Calculate the k-core Follower;

[0013] S4: Maintain the onion layer structure.

[0014] Preferably, the specific process of step S1 of the present invention is as follows: the graph data is decomposed by kernel, and divided into shells according to coreness. Within each shell, the vertices are divided into their respective levels according to the order in which the vertices are stripped in the kernel decomposition under batch processing. The neighbors of the vertices are divided into different relationships according to their respective levels, namely NO outer neighbors, NS same-level neighbors, and NI inner neighbors.

[0015] Preferably, the specific process of step S2 of the present invention is as follows: traverse all vertices to find vertices with (k-1)-shell neighbors, and classify them into Core-Adjacent Vertices and Non-Core-Adjacent Vertices according to whether they have neighbor vertices in the k-core subgraph; use a filtering strategy based on inclusion relationship for the two types of vertices to filter out vertices that are not included; then, use an adaptive strategy to filter out candidate set vertices from the filtered Core-Adjacent Vertices and Non-Core-Adjacent Vertices.

[0016] Preferably, the specific process of step S3 of the present invention is as follows: Based on the candidate set vertices obtained in S2, they are combined into candidate pairs. For each candidate pair, the k-core follower calculation method based on the onion layer structure is used to calculate the number of k-core followers and (k-1)-core followers, as well as the number of followers reduced in (k-1)-shells. If the number of k-core followers and (k-1)-core followers is not equal to 0 in this calculation, it is judged as a valid calculation. During the budget iteration process, when the budget is not used for the last time, max|V(C) is selected. k (G(u,v)))+V(C k-1 Candidate pairs of (G(u,v)))| are merged; when the last budget is used, max|F is selected. k Candidate pairs of (u,v)|.

[0017] Preferably, the specific process of step S4 of the present invention is as follows: Based on the candidate pair {u,v} obtained in S3, the edge of vertex v is transferred to vertex u. If there is a duplicate edge, no duplicate edge will be constructed, only one edge will be retained, and vertex v will be deleted. Then, according to the maintenance method of the onion layer structure, the first case is maintained first, the second case is maintained, and the third case is maintained last.

[0018] A system for implementing the maximization method of the present invention includes the following modules:

[0019] Graph data preprocessing module: responsible for storing the raw graph data into memory and constructing an onion layer structure to obtain the layer number of each vertex and the relationship between neighboring layers;

[0020] Candidate set filtering module: Based on the candidate set strategy and adaptive strategy of Core-Adjacent Vertices, and combined with inclusion relationship filtering and pruning strategy to generate candidate set vertices;

[0021] Follower calculation module: Based on the onion layer structure, the k-core follower calculation method quickly calculates the evaluation scores of candidate pairs, such as k-core follower and (k-1)-core follower.

[0022] Onion layer structure maintenance module: Based on the maintenance method of onion layer structure, maintain the onion layer structure whose local structure changes due to vertex merging.

[0023] The technical solution of this invention has the following advantages compared with the prior art:

[0024] 1. The k-core follower computation method based on the onion layer structure can significantly reduce the time cost by 3-4 orders of magnitude compared to traditional algorithms.

[0025] 2. The candidate set strategy and adaptive strategy based on Core-Adjacent Vertices can effectively solve the problem that effective results cannot be calculated in some cases.

[0026] 3. Based on the inclusion relationship, the filtering strategy and various pruning strategies can further reduce the time cost of the algorithm and increase the number of calculated k-core followers on the basis of the above methods. Attached Figure Description

[0027] Figure 1 This is a schematic diagram of the method flow of the present invention;

[0028] Figure 2 This is graph data from one embodiment of the present invention;

[0029] Figure 3 This is an onion layer structure corresponding to one embodiment of the present invention. Detailed Implementation

[0030] To make the objectives, technical solutions, and advantages of this invention clearer, the following detailed description of the invention is provided in conjunction with specific embodiments. However, this invention is not limited to the following specific embodiments.

[0031] A method for maximizing a k-core subgraph that satisfies kernel value and budget constraints includes:

[0032] 1. A k-core follower calculation and maintenance method based on an onion layer structure;

[0033] 2. Candidate set strategy and adaptive strategy based on Core-Adjacent Vertices;

[0034] 3. Filtering strategies based on inclusion relationships and multiple pruning strategies.

[0035] This invention reduces time overhead by designing a k-core follower computation and maintenance method based on an onion-layer structure to analyze structural changes caused by the "vertex merging" operation. It addresses situations where effective results cannot be computed under extreme conditions, such as when the budget value or target kernel value is too large, by designing a candidate set strategy and an adaptive strategy based on Core-Adjacent Vertices. This invention outperforms existing methods in both runtime and the number of valid results computed, demonstrating strong applicability and significant effectiveness.

[0036] The graph is an undirected, unweighted graph G, defined as G = (V, E), where V is the set of vertices and E is the set of edges. The kernel value k refers to the kernel constraint threshold of the k-core, and the budget b refers to the maximum number of merge operations allowed, with each merge consuming 1 unit of budget.

[0037] Vertex merging refers to merging two vertices {u,v} into a new vertex u, transferring all neighboring edges of vertex v to vertex u, removing self-loops and multiple edges, and deleting vertex v.

[0038] The k-core follower is defined as: F k (u,v)=V(C k (G(u,v)))\V(C k (G)) indicates that it exists in V(C) k G(u,v)) does not exist in V(C). k The vertices of (G)). Where G(u,v) is the graph after merging vertices u and v, and C k (G) is a k-core subgraph of G. Here, k-shell is the set of vertices with coreness = k.

[0039] The onion layer structure, based on k-core decomposition, divides vertices within the same k-shell into multiple layers according to the order in which they were peeled during batch kernel decomposition. It also supports local propagation evaluation by maintaining the layer number and related metrics (such as k-degree and shell-degree) for each vertex. Specifically, the k-degree of a vertex is initialized to the number of its neighbors in the k-core subgraph. Vertices with k-degree equal to coreness are designated as the outermost layer. The k-degree of other vertices is then reduced by the number of neighbors in the outermost layer. Vertices with k-degree ≤ coreness are then designated as layer 1, and so on.

[0040] Shell-degree refers to the number of all neighbors of a vertex in the k-core subgraph. K-degree refers to the number of neighbors in the (k+1)-core subgraph plus the number of neighbors in the k-shell subgraph with the same or higher level as the vertex, which is shell-degree minus the number of neighbors in the k-core subgraph with a lower level than the current vertex.

[0041] The k-core follower calculation method based on the onion layer structure refers to finding vertices whose core values ​​change due to vertex merging based on the rule of vertex core value changes in a graph with onion layers.

[0042] Specifically, assuming u and v are merged vertices, there are two cases. The first is the case of kernel value promotion. First, locate the neighbors of u and v in the (k-1)-shell whose layer number is higher than u and v, and increment the k-degree of these neighbors by 1. Then, propagate and update layer by layer according to the hierarchical relationship, starting from the layer of the outermost neighbor vertex and moving down layer by layer, incrementing the k-degree of the neighbors of the neighbor vertex in the next layer by 1. Until the bottom layer of the (k-1)-shell is reached, when the condition for entering the k-core is met, that is, the number of vertices with k-degree ≥ k is greater than or equal to k, the corresponding vertex and the merged vertex are both k-core followers.

[0043] The second is the case of coreness reduction. Let the minimum coreness of u and v be minC. First, determine the common neighbors of u and v with coreness ≤ minC. Then, find the vertices that are in the outermost layer, i.e., the vertices with layer number 0 among these neighbors. Decrease the shell-degree of these vertices by 1, and then decrease the shell-degree of the neighbor vertices of these vertices by 1. If the shell-degree of a new vertex < coreness, repeat the above operations. Finally, uniformly reduce the coreness of all vertices with shell-degree < coreness by 1. During the budget iteration process, when it is not the last budget usage, select the candidate pair with max|V(C k (G(u,v)))+V(C k-1 (G(u,v)))| for merging. When it is the last budget usage, select the candidate pair with max|F k (u,v)|.

[0044] Among them, the method for maintaining the onion layer structure refers to maintaining three structural changes caused by vertex merging. The first is the case of coreness increase. The vertex newly entering the core is used as a follower, and the related neighborhood vertices of its original shell are used as remains. Synchronously process the follower vertices and the remains vertices of the current shell. According to the relationship between k-degree and coreness, that is, k-degree ≤ coreness, gradually adjust the levels from the outer layer to the inner layer until the level stability condition is satisfied. If the k-degree of the neighbor vertex > coreness is caused during the process, it is added to the processing.

[0045] The second is the case of coreness decrease. The set of vertices with reduced core value is denoted as leaver, and the neighbors of the leaver vertices in the original shell are denoted as remains. First process the remains vertices of the current shell and then process the leaver vertices. According to the relationship between k-degree and coreness, first, move the levels of the remains vertices to determine the remains vertices located in the 0th layer, and then move the levels of the remains vertices whose levels are not determined and their neighbors to determine the vertices in the 1st layer. Gradually adjust the levels from the outer layer to the inner layer until the level stability condition is satisfied. If the k-degree of the neighbor plus the number of neighbors in the previous layer still satisfies k-degree ≤ coreness during the process, it is added to the processing. When all the above vertices are processed, then use the method in the first case to process the leaver vertices.

[0046] The third case is when the coreness remains unchanged while the level changes. All such vertices become remains vertices due to follower vertices or leaver vertices. Most of the vertex maintenance can be completed according to the above methods. If there are remains vertices that become such due to both follower vertices and leaver vertices, first use the method of the second case and then the method of the first case to complete the maintenance.

[0047] The candidate set strategy based on Core-Adjacent Vertices refers to classifying vertices with neighbors in the (k - 1)-shell into Core-Adjacent Vertices and Non-Core-Adjacent Vertices according to whether the vertices have neighbor vertices within the k-core subgraph. Further divide out-vertices and shell-vertices within the above two types of vertices. Select x1 out-vertices and x2 shell-vertices within Core-Adjacent Vertices, and select y1 out-vertices and y2 shell-vertices within Non-Core-Adjacent Vertices. Here, x1, x2, y1, y2 ∈ Z+.

[0048] The adaptive strategy means selecting vertices with higher scores on the basis of ensuring that there is at least one vertex in each of the 4 types of vertices according to the scores of the vertices. The score of a vertex refers to the value obtained by subtracting the number of neighbors of the vertex in the (k - 1)-shell with a higher level than the vertex from k.

[0049] The screening strategy based on the inclusion relationship means that if a vertex A and another vertex B have the same number of neighbors in the k-core subgraph and the set of neighbors of A in the (k - 1)-shell with a higher level than A is included in the set of neighbors of B in the (k - 1)-shell with a higher level than B, then A is said to be included by B and B is retained. There are mainly two types of the multiple pruning strategies. The first is that during the process of screening candidate pairs, if the number of neighbors of two vertices in the (k - 1)-core subgraph < k, pruning can be performed in advance. The second is that during the process of calculating k-core followers, based on the theory that if the number of neighbors of the new vertex after merging in the (k - 1)-core subgraph with k-degree ≥ k < k, then the vertex pair can be pruned in advance, this is applied in each module.

[0050] As Figure 1 shown, a method for maximizing the k-core subgraph that satisfies the core value and budget constraints includes the following steps:

[0051] S1: Preprocess the graph data and construct the onion layer structure.

[0052] The specific process is as follows: The graph data is decomposed using a kernel, and divided into shells based on coreness. Within each shell, vertices are assigned to different levels according to the order in which they were stripped during the batch kernel decomposition. The neighbors of each vertex are then classified into different relationships based on their level: NO (neighbor of the outer layer), NS (neighbor of the same layer), and NI (neighbor of the inner layer).

[0053] like Figure 2 As shown, Figure 2 It is an undirected, unweighted graph. The vertices in the 2-shell are {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, and the vertices in the 3-shell are {11, 12, 13, 14}. Following the onion layer method, divide the vertices of the 2-shell and 3-shell into different levels. Figure 3 Given Figure 2 The hierarchy corresponding to the mid-vertex and the corresponding NO, NS, NI partitions.

[0054] S2: Filter the candidate set.

[0055] The specific process is as follows: Traverse all vertices to find vertices with (k-1)-shell neighbors. Based on whether they have neighbors within the k-core subgraph, vertices are categorized into Core-Adjacent Vertices and Non-Core-Adjacent Vertices. A filtering strategy based on inclusion relations is applied to both categories to filter out vertices that are not included. Then, an adaptive strategy is used to filter the selected Core-Adjacent Vertices and Non-Core-Adjacent Vertices to obtain a candidate set of vertices.

[0056] S3: Calculate the k-core Follower.

[0057] The specific process is as follows: Based on the candidate set vertices obtained from S2, pair them into candidate pairs. For each candidate pair, use the k-core follower calculation method based on the onion layer structure to calculate the number of k-core followers and (k-1)-core followers, as well as the number of followers reduced in the (k-1)-shell. If the number of k-core followers and (k-1)-core followers is not equal to 0 in this calculation, it is considered a valid calculation. During the budget iteration process, when not using the last budget, choose max|V(C) k (G(u,v)))+V(C k-1 Candidate pairs of (G(u,v)))| are merged. When the last budget is used, max|F is selected. k Candidate pairs of (u,v)|.

[0058] S4: Maintain the onion layer structure.

[0059] The specific process is as follows: Based on S3, candidate pairs are obtained. For example, if the candidate pair is {u,v}, the edge of vertex v is transferred to vertex u. If there are duplicate edges, no duplicate edges are constructed; only one edge is retained, and vertex v is deleted. Then, according to the maintenance method of the onion layer structure, the first case is maintained first, then the second case, and finally the third case.

[0060] A system for maximizing a k-core subgraph that satisfies kernel value and budget constraints includes the following modules:

[0061] Graph data preprocessing module: responsible for storing the raw graph data into memory and constructing an onion layer structure to obtain the layer number of each vertex and the relationship between neighboring layers;

[0062] Candidate set filtering module: Based on the candidate set strategy and adaptive strategy of Core-Adjacent Vertices, and combined with inclusion relationship filtering and pruning strategy to generate candidate set vertices;

[0063] Follower calculation module: Based on the onion layer structure, the k-core follower calculation method quickly calculates the evaluation scores of candidate pairs, such as k-core follower and (k-1)-core follower.

[0064] Onion layer structure maintenance module: Based on the maintenance method of onion layer structure, maintain the onion layer structure whose local structure changes due to vertex merging.

[0065] Obviously, the above embodiments of the present invention are merely examples for clearly illustrating the present invention, and are not intended to limit the implementation of the present invention. Those skilled in the art can make other variations or modifications based on the above description. It is neither necessary nor possible to exhaustively describe all embodiments here. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of the present invention should be included within the scope of protection of the claims of the present invention.

Claims

1. A method for maximizing a k-core subgraph that satisfies kernel value and budget constraints, characterized in that... Includes the following steps: S1: Preprocess the graph data and construct the onion layer structure; S2: Filter the candidate set; S3: Calculate the k-core Follower; S4: Maintain the onion layer structure.

2. The maximization method according to claim 1, characterized in that... The specific process of step S1 above is as follows: Decompose the graph data into shells based on coreness. Within each shell, vertices are classified into their respective levels according to the order in which they were stripped during the batch kernel decomposition. The neighbors of vertices are classified into different relationships based on their respective levels, namely NO outer neighbors, NS same-level neighbors, and NI inner neighbors.

3. The maximization method according to claim 2, characterized in that... The specific process of step S2 above is as follows: Traverse all vertices to find vertices with (k-1)-shell neighbors, and classify them into Core-Adjacent Vertices and Non-Core-Adjacent Vertices based on whether they have neighbor vertices in the k-core subgraph; A filtering strategy based on inclusion relationships is used for the two types of vertices to filter out vertices that are not included; then, an adaptive strategy is used to filter out candidate vertices from the filtered Core-Adjacent Vertices and Non-Core-Adjacent Vertices.

4. The maximization method according to claim 3, characterized in that... The specific process of step S3 above is as follows: Based on the candidate set vertices obtained in S2, pair them into candidate pairs. For each candidate pair, use the k-core follower calculation method based on the onion layer structure to calculate the number of k-core followers and (k-1)-core followers, as well as the number of followers reduced in (k-1)-shells. If the number of k-core followers and (k-1)-core followers is not equal to 0 in this calculation, it is considered a valid calculation. During the budget iteration process, when not using the last budget, select max|V(C) k (G(u,v)))+V(C k-1 Candidate pairs of (G(u,v)))| are merged; when the last budget is used, max|F is selected. k Candidate pairs of (u,v)|.

5. The maximization method according to claim 4, characterized in that... The specific process of step S4 above is as follows: Based on the candidate pair {u,v} obtained in S3, the edge of vertex v is transferred to vertex u. If there is a duplicate edge, no duplicate edge will be constructed, only one edge will be kept, and vertex v will be deleted. Then, according to the maintenance method of the onion layer structure, the first case is maintained first, the second case is maintained, and the third case is maintained last.

6. The maximization method according to claim 5, characterized in that... The first case mentioned above is the case where coreness increases. The newly added vertices entering the core are treated as followers, and the relevant neighboring vertices of their original shell are treated as remains. Synchronously process follower vertices and the remaining vertices of the current shell. Based on the relationship between k-degree and coreness, i.e., k-degree ≤ coreness, gradually adjust the level from the outer layer to the inner layer until the level stability condition is met. If the process causes neighboring vertices to have k-degree > coreness, then add them to the processing.

7. The maximization method according to claim 5, characterized in that... The second scenario described above involves a decrease in coreness. The set of vertices with reduced coreness is denoted as leaver, and the neighbors of leaver vertices in the original shell are denoted as remains. The remains vertices of the current shell are processed first, followed by the leaver vertices. Based on the relationship between k-degree and coreness, first, the levels of the remains vertices are moved to determine the remains vertices at level 0. Then, the levels of the remains vertices whose levels are not yet determined, along with their neighbors, are moved to determine the vertices at level 1. The levels are gradually adjusted from the outermost layer to the innermost layer until the level stability condition is met. If, during this process, the k-degree of a neighbor plus the number of neighbors in the previous layer still satisfies k-degree ≤ coreness, then it is added to the processing. Once all the above vertices have been processed, the leaver vertices are processed using the method described in the first scenario.

8. The maximization method according to claim 5, characterized in that... The third case mentioned above is when the coreness remains unchanged but the level changes. These vertices are all remaining vertices because of follower vertices or learner vertices. The maintenance of most vertices can be completed using the method described above. If there are remaining vertices that are both becoming follower vertices and learner vertices, the method of the second case should be used first, followed by the method of the first case to complete the maintenance.

9. A system for implementing the maximization method according to any one of claims 1-5, characterized in that... Includes the following modules: Graph data preprocessing module: responsible for storing the raw graph data into memory and constructing an onion layer structure to obtain the layer number of each vertex and the relationship between neighboring layers; Candidate set filtering module: Based on the candidate set strategy and adaptive strategy of Core-Adjacent Vertices, and combined with inclusion relationship filtering and pruning strategy to generate candidate set vertices; Follower calculation module: Based on the onion layer structure, the k-core follower calculation method quickly calculates the evaluation scores of candidate pairs, such as k-core follower and (k-1)-core follower. Onion layer structure maintenance module: Based on the maintenance method of onion layer structure, maintain the onion layer structure whose local structure changes due to vertex merging.

Images