networkX 图拆分为多个子图

如何解决networkX 图拆分为多个子图

亲爱的

我有一个包含 300 万个节点的图，由许多具有 2/3/4 个节点的子图和一些高达 8000/9000 个节点的子图组成。我的愿望是将这个大图拆分为子图，每个子图最多有 5 个节点。

对于已经满足此条件的每个子图 - 我保持原样。对于每个节点超过 5 个的节点，我会找到权重最小的边并将其删除（该图是加权的）。

然而，我认为我的实现完全是一场灾难，运行时间将比我的寿命更长。

def return_ab(dc):
    #Expects,return the key with the minimum value
    mn = min(list(dc.values()))
    #print(mn)
    return list(dc.keys())[list(dc.values()).index(mn)]

ls_gr_1 = []
rem_edges_1 = []
def prune(grph):
    if grph.size() <= 5:
        ls_gr_1.append(grph)
    
    else:
        ls = nx.get_edge_attributes(grph,'DURATION')
        min = return_ab(ls)
        #print(min)
        unfrozen_graph = nx.Graph(grph)
        #print(min)
        rem_edges_1.append(min)
        unfrozen_graph.remove_edge(*min)
        
        for c in nx.connected_components(unfrozen_graph):
            
            prune(unfrozen_graph.subgraph(c))

我希望能以更优雅、更快速的方式实现这一点...

编辑：

我尝试了迭代，这似乎有点快，但仍然太慢：


def traverse(graph):
    components = [graph.subgraph(c).copy() for c in nx.connected_components(graph)]
    large_ones = components
    
    small_ones = []
    
    while large_ones:
        graph_to_work = large_ones.pop()
        if len(graph_to_work) <= 5:
            small_ones.append(graph_to_work)
        else:
            ls = nx.get_edge_attributes(graph_to_work,'DURATION')
            min = return_ab(ls)
            unfrozen_graph = nx.Graph(graph_to_work)
            unfrozen_graph.remove_edge(*min)
            new_components = [unfrozen_graph.subgraph(c).copy() for c in nx.connected_components(unfrozen_graph)]
            large_ones.extend(new_components)
            
    return small_ones

解决方法

要获得具有 5 个或更多节点的子图，请尝试以下操作：

min_net_size=5
components=list(nx.connected_components(G))

for component in components:
    if len(component) < min_net_size:  # remove small networks
        for node in component:
            G.remove_node(node)

我使用它并且它可以快速获取组件。然后，您可以根据需要处理它们。

例如计算所有较大组件的信息：

components=list(nx.connected_components(G))#reevauate now removed smaller ones so can get a value for n which is used to select the largest n components
n = min(250,len(components))

largest_components = sorted(nx.connected_components(G),key=len,reverse=True)[:n]


for index in range(n):
    print('Component no. ',index)
    component=G.subgraph(largest_components[index])

    if len(component.nodes)<1000: #ignore really big ones!
        spring_3D = nx.spring_layout(component,dim=3,k=0.75,seed=42)  
        edges = component.edges()
        nodes=component.nodes()
#Progress from here with whatever you need to do