def partition_girvan_newman(graph, max_depth): """ Use your approximate_betweenness implementation to partition a graph. Unlike in class, here you will not implement this recursively. Instead, just remove edges until more than one component is created, then return those components. That is, compute the approximate betweenness of all edges, and remove them until multiple comonents are created. You only need to compute the betweenness once. If there are ties in edge betweenness, break by edge name (e.g., (('A', 'B'), 1.0) comes before (('B', 'C'), 1.0)). Note: the original graph variable should not be modified. Instead, make a copy of the original graph prior to removing edges. See the Graph.copy method https://networkx.github.io/documentation/development/reference/generated/networkx.Graph.copy.html Params: graph.......A networkx Graph max_depth...An integer representing the maximum depth to search. Returns: A list of networkx Graph objects, one per partition. >>> components = partition_girvan_newman(example_graph(), 5) >>> components = sorted(components, key=lambda x: sorted(x.nodes())[0]) >>> sorted(components[0].nodes()) ['A', 'B', 'C'] >>> sorted(components[1].nodes()) ['D', 'E', 'F', 'G'] """ ###TODO copy = graph.copy() partition_edge = list(sorted(approximate_betweenness(copy, max_depth).items(), key=lambda x:(-x[1], x[0]))) for i in range(0, len(partition_edge)): copy.remove_edge(*partition_edge[i][0]) subgraphs = list(nx.connected_component_subgraphs(copy)) if len(subgraphs) > 1: break return subgraphs
def volume(nodes, graph): """ Compute the volume for a list of nodes, which is the number of edges in `graph` with at least one end in nodes. Params: nodes...a list of strings for the nodes to compute the volume of. graph...a networkx graph >>> volume(['A', 'B', 'C'], example_graph()) 4 """ #volume = nx.volume(graph, nodes, weight=None) copy = graph.copy() edgeV = 0 for n in nodes: for e in copy.edges(): if n == e[0] or n == e[1]: edgeV += 1 copy.remove_edge(*e) return edgeV
def make_training_graph(graph, test_node, n): """ To make a training graph, we need to remove n edges from the graph. As in lecture, we'll assume there is a test_node for which we will remove some edges. Remove the edges to the first n neighbors of test_node, where the neighbors are sorted alphabetically. E.g., if 'A' has neighbors 'B' and 'C', and n=1, then the edge ('A', 'B') will be removed. Be sure to *copy* the input graph prior to removing edges. Params: graph.......a networkx Graph test_node...a string representing one node in the graph whose edges will be removed. n...........the number of edges to remove. Returns: A *new* networkx Graph with n edges removed. In this doctest, we remove edges for two friends of D: >>> g = example_graph() >>> sorted(g.neighbors('D')) ['B', 'E', 'F', 'G'] >>> train_graph = make_training_graph(g, 'D', 2) >>> sorted(train_graph.neighbors('D')) ['F', 'G'] """ ###TODO # copy a new graph copy = graph.copy() neighbor_nodes = sorted(copy.neighbors(test_node)) for i in range(n): copy.remove_edge(*(test_node, neighbor_nodes[i])) return copy
def partition_girvan_newman(graph, max_depth): """ Use your approximate_betweenness implementation to partition a graph. Unlike in class, here you will not implement this recursively. Instead, just remove edges until more than one component is created, then return those components. That is, compute the approximate betweenness of all edges, and remove them until multiple comonents are created. Params: graph.......A networkx Graph max_depth...An integer representing the maximum depth to search. Returns: A list of networkx Graph objects, one per partition. """ copy = graph.copy() betweenness = sorted(approximate_betweenness(copy, max_depth).items(), key= lambda x: (-x[1],x[0][0],x[0][1])) for edge,val in betweenness: copy.remove_edge(*edge) if nx.number_connected_components(copy) > 1: break partition_graph = sorted(list(nx.connected_component_subgraphs(copy)), key = lambda x: -len(x)) return partition_graph
def volume(nodes, graph): """ Compute the volume for a list of nodes, which is the number of edges in `graph` with at least one end in nodes. Params: nodes...a list of strings for the nodes to compute the volume of. graph...a networkx graph >>> volume(['A', 'B', 'C'], example_graph()) 4 """ ###TODO volumn = 0 copy = graph.copy() for n in range(0, len(nodes)): for e in copy.edges(): if nodes[n] == e[0] or nodes[n] == e[1]: copy.remove_edge(*e) volumn += 1 return volumn