def get_color(i, r_off=1, g_off=1, b_off=1): n = 16 low, high = 0.1, 0.9 span = high - low r = low + span * (((i + r_off) * 4) % n) / (n - 1) g = low + span * (((i + g_off) * 8) % n) / (n - 1) b = low + span * (((i + b_off) * 12) % n) / (n - 1) return (r, g, b) G = nx.read_gexf('../../dataset/graph-small/graph.gexf') # Remove social media accounts and isolates from the dataset G = remove_unnecessary_data(G) communities = girvan_newman(G) node_groups = [] for community in next(communities): node_groups.append(list(community)) node_colors = [] for ng in range(len(node_groups)): for node in G: if node in node_groups[ng]: node_colors.append(get_color(ng)) nx.draw(G, node_color=node_colors) plt.show()
# print(adjmat) # Construct a networkx graph from the adjacency matrix # (Singleton nodes are excluded from the graph) G = make_graph(adjmat, labels=Config.labels) # nx.draw(G, with_labels=True) """--- # ##Community detection using Girvan-Newman # """ from networkx.algorithms.community.centrality import girvan_newman # from networkx.algorithms.community import k_clique_communities comp = girvan_newman(G) max_shown = 1 shown_count = 1 possibilities = [] for communities in itertools.islice(comp, max_shown): # print(communities) # a tuple # print("Possibility", shown_count, ": ", end='') # print(communities) possibilities.append(communities) color_map = ["" for x in range(len(G))] color = 0 for c in communities: indices = [i for i, x in enumerate(G.nodes) if x in c] for i in indices: color_map[i] = Config.colors[color]
def main(): # Load data nodes = pd.read_csv("../data/nodes.csv", sep='\t', index_col=0) # Data in nice form headers = list(nodes.columns) nodes = np.asarray(nodes) # Load social network accordingly edges = pd.read_csv("../data/edges.csv", sep='\t', index_col=0) edges = np.asarray(edges).astype(int) G = nx.Graph() G.add_nodes_from(range(nodes.shape[0])) G.add_edges_from(list(map(tuple, edges))) #first compute the best partition print("Computing Girvan Newman Algorithm") start = timeit.default_timer() comp = girvan_newman(G) print(tuple(sorted(c) for c in next(comp))) ''' max_iterations = 100 for i in range(max_iterations): print(gir[i]) ''' stop = timeit.default_timer() # Computing modularity ''' num_cmtys = len(set(partition.values())) num_edges = edges.shape[0] cmtys = [[] for _ in range(num_cmtys)] for node in partition.keys(): cmtys[partition[node]].append(node) # Load social network accordingly if path.exists("../data/youtube.graph"): FIn = snap.TFIn("../data/youtube.graph") social_network = snap.TNGraph.Load(FIn) else: social_network = data2dag(edges, nodes.shape[0]) ''' ''' modularity = 0 for cmty in cmtys: Nodes = snap.TIntV() for elem in cmty: Nodes.Add(int(elem)) modularity += snap.GetModularity(social_network, Nodes, num_edges) ''' ''' print("Calculating Modularity") assert(is_partition(G, cmtys)) modul = modularity(G, cmtys) print("Results from Louvain:") print("Modularity:",modul) print("Number of clusters:",num_cmtys) print("Time elapsed:",stop - start) ''' #drawing '''
def get_network_partitions(self, matrix, num_groups, threshold=0.5): first_array = matrix.nonzero()[0] second_array = matrix.nonzero()[1] # print("num edges before filter: " + str(len(first_array))) graph = nx.Graph() nodes = set() weights_dict = {} # print(len(first_array)) for i in range(len(first_array)): if first_array[i] < second_array[i] and matrix[first_array[i], second_array[i]] > threshold: weights_dict[i] = matrix[first_array[i], second_array[i]] num_edges = 0 sorted_weights = [i for i in sorted(weights_dict, key=weights_dict.get, reverse=True)] limit = min(len(sorted_weights), 1000) for i in sorted_weights[0: limit]: nodes.add(first_array[i]) nodes.add(second_array[i]) graph.add_edge(first_array[i], second_array[i]) num_edges += 1 #print("num nodes after filter: " + str(len(nodes))) graph.add_nodes_from(list(nodes)) nodes = list(nodes) nodes_to_remove = [] for sub_graph in connected_components(graph): if len(sub_graph) < 4: for node_id in sub_graph: nodes_to_remove.append(node_id) del nodes[nodes.index(node_id)] # print("num nodes after cliques: " + str(len(nodes))) for node_id in nodes_to_remove: graph.remove_node(node_id) comp = girvan_newman(graph) partition = () for communities in comp: partition = tuple(sorted(c) for c in communities) if len(partition) >= num_groups: break elif len(partition) > num_groups: partition = self.reduce_partition(partition, num_groups) break else: continue parts = [-1] * len(nodes) for group_id, group in enumerate(partition): for index in group: parts[nodes.index(index)] = group_id modified_parts = [] modified_nodes = [] for i, part in enumerate(parts): if part >= 0: modified_parts.append(part) modified_nodes.append(nodes[i]) return modified_nodes, modified_parts, graph
import networkx as nx import pandas as pd import matplotlib.pyplot as plt import itertools from networkx.algorithms.community.centrality import girvan_newman B = pd.read_csv('dm-graphtask-adj.txt', header=None) G = nx.from_numpy_matrix(B.values) comp = girvan_newman(G, most_valuable_edge=None) k = 4 counter = 0 clusters = [] for communities in itertools.islice(comp, k): if counter == 3: for c in communities: nodelist = list(c) clusters.append(nodelist) print (nodelist) counter += 1 pos = nx.spring_layout(G) # nodes colors = ['r', 'g', 'b', 'y', 'm']
elif (partition[node] == 3): color_list.append("Blue") elif (partition[node] == 4): color_list.append("Purple") elif (partition[node] == 5): color_list.append("Green") elif (partition[node] == 6): color_list.append("Brown") drawGraph(G, color_list, False) ''' ####################################################################### Step 10 output: Girvan-Newman a) Output the number of communities, the size of largest community, size of smallest community, and modularity of this partitioning #######################################################################''' components = c.girvan_newman(G) i = 0 for row in components: if (i == 0): finalResult = row # print(row) i += 1 minCommunity = len(list(G.nodes)) + 1 maxCommunity = 0 ctr = 0 partitions = dict() L = list(finalResult) p = 0 for comp in L: for entry in comp:
# and add some random noise. centrality = {e: c / max_cent for e, c in centrality.items()} # Add some random noise. centrality = {e: c + random() for e, c in centrality.items()} return max(centrality, key=centrality.get) G = nx.path_graph(10) if len(sys.argv) < 2: sys.stderr.write("Usage: %s <input graph>\n" % (argv[0], )) sys.exit(1) graph_fn = sys.argv[1] G = nx.Graph() #let's create the graph first buildG(G, graph_fn, '\t') comp = girvan_newman(G, most_valuable_edge=most_central_edge) com = 0 thisdict = {} # Populating the items of the dictionary for c in next(comp): list = sorted(c) for i in range(len(list)): if list[i] in thisdict: print('already found') else: thisdict.update({list[i]: com}) i += 1 com += 1 dict_nodes_girvan = {}