def get_base_modularity_matrix(network): ''' Obtain the modularity matrix for the whole network. Assumes any edge weights use the key 'weight' in the edge attribute. Parameters ---------- network : nx.Graph or nx.DiGraph The network of interest Returns ------- np.matrix The modularity matrix for `network` Raises ------ TypeError When the input `network` does not fit either nx.Graph or nx.DiGraph ''' if type(network) == nx.Graph: if nx.is_weighted(network): return sparse.csc_matrix(nx.modularity_matrix(network,weight='weight')) return sparse.csc_matrix(nx.modularity_matrix(network)) elif type(network) == nx.DiGraph: if nx.is_weighted(network): return sparse.csc_matrix(nx.directed_modularity_matrix(network,weight='weight')) return sparse.csc_matrix(nx.directed_modularity_matrix(network)) else: raise TypeError('Graph type not supported. Use either nx.Graph or nx.Digraph')
def test_modularity(self): "Modularity matrix" B = np.array([[-1.125, 0.25, 0.25, 0.625, 0.], [0.25, -0.5, 0.5, -0.25, 0.], [0.25, 0.5, -0.5, -0.25, 0.], [0.625, -0.25, -0.25, -0.125, 0.], [0., 0., 0., 0., 0.]]) permutation = [4, 0, 1, 2, 3] npt.assert_equal(nx.modularity_matrix(self.G), B) npt.assert_equal(nx.modularity_matrix(self.G, nodelist=permutation), B[np.ix_(permutation, permutation)])
def test_modularity(self): "Modularity matrix" B = numpy.matrix([[-1.125, 0.25 , 0.25 , 0.625, 0. ], [ 0.25 , -0.5 , 0.5 , -0.25 , 0. ], [ 0.25 , 0.5 , -0.5 , -0.25 , 0. ], [ 0.625, -0.25 , -0.25 , -0.125, 0. ], [ 0. , 0. , 0. , 0. , 0. ]]) permutation = [4, 0, 1, 2, 3] assert_equal(nx.modularity_matrix(self.G), B) assert_equal(nx.modularity_matrix(self.G, nodelist=permutation), B[numpy.ix_(permutation, permutation)])
def test_modularity_weight(self): "Modularity matrix with weights" B = numpy.matrix([[-1.125, 0.25 , 0.25 , 0.625, 0. ], [ 0.25 , -0.5 , 0.5 , -0.25 , 0. ], [ 0.25 , 0.5 , -0.5 , -0.25 , 0. ], [ 0.625, -0.25 , -0.25 , -0.125, 0. ], [ 0. , 0. , 0. , 0. , 0. ]]) G_weighted = self.G.copy() for n1, n2 in G_weighted.edges(): G_weighted.edge[n1, n2]["weight"] = 0.5 # The following test would fail in networkx 1.1 assert_equal(nx.modularity_matrix(G_weighted), B) # The following test that the modularity matrix get rescaled accordingly assert_equal(nx.modularity_matrix(G_weighted, weight="weight"), 0.5*B)
def test_modularity_weight(self): "Modularity matrix with weights" B = numpy.matrix([[-1.125, 0.25 , 0.25 , 0.625, 0. ], [ 0.25 , -0.5 , 0.5 , -0.25 , 0. ], [ 0.25 , 0.5 , -0.5 , -0.25 , 0. ], [ 0.625, -0.25 , -0.25 , -0.125, 0. ], [ 0. , 0. , 0. , 0. , 0. ]]) G_weighted = self.G.copy() for n1, n2 in G_weighted.edges(): G_weighted.edge[n1][n2]["weight"] = 0.5 # The following test would fail in networkx 1.1 assert_equal(nx.modularity_matrix(G_weighted), B) # The following test that the modularity matrix get rescaled accordingly assert_equal(nx.modularity_matrix(G_weighted, weight="weight"), 0.5*B)
def cluster(G): """ Splits graph G into two communities :param G: NetworkX graph to cluster :return: solution bitstring :rtype: list """ logging.info("Computing coarsening hierarchy...") hierarchy = coarsen(G) logging.info("Done computing coarsening hierarchy") curr_solution = None for level, (graph, matching) in zip( range(len(hierarchy) - 1, -1, -1), reversed(hierarchy) ): # http://christophe-simonis-at-tiny.blogspot.com/2008/08/python-reverse-enumerate.html logging.info("Now at level {}".format(level)) B = nx.modularity_matrix(graph) print(graph.number_of_nodes(), B) if curr_solution is None: # first level -- initial solution _, curr_solution = gm.optimize_modularity(graph.number_of_nodes(), B) print(curr_solution) break
def modularity_cluster(g, cap = 200): ''' Cluster the graph based on Newman's algorithm. M. E. J. Newman, "Modularity and community structure in networks", Proc. Natl. Acad. Sci. USA, vol. 103, pp. 8577-8582, 2006. Useful Links: - Modularity matrix: https://goo.gl/AQ7ZUC - Complex number in Eigenvalue issue: https://goo.gl/APvxRn - Benchmark Eigenvalues with Matlab: https://goo.gl/3giVRU ''' if(g.number_of_nodes() < cap): return [] mm = nx.modularity_matrix(g) e = eigh(mm, eigvals_only=True) pmask = np.array([i > 0 for i in e]) nmask = np.array(list(map(operator.not_, pmask))) indicies = np.array(g.nodes()) ep = indicies[pmask] en = indicies[nmask] if(len(ep) < cap or len(en) < cap): return [g] gpart1 = g.subgraph(ep) gpart2 = g.subgraph(en) # logging.debug("cluster: (%d, %d) -> (%d, %d) (%d, %d)" % (g.number_of_nodes(), g.number_of_edges(), gpart1.number_of_nodes(), gpart1.number_of_edges(), gpart2.number_of_nodes(), gpart2.number_of_edges())) return modularity_cluster(gpart1, cap) + modularity_cluster(gpart2, cap)
def graph2dat(graph): folder = "" mygraphfile = open(folder + "neg_modularity.dat", 'w') data_var = {} data_var['couplers'] = 'set couplers :=\n' data_var['nodes'] = 'set nodes :=\n' data_var['bias'] = 'param bias := \n' data_var['weight'] = 'param w := \n' modularity_mat = nx.modularity_matrix(graph, nodelist=sorted(graph.nodes())) n = nx.number_of_nodes(graph) for i in range(n - 1): for j in range(i, n): w = -modularity_mat.item((i, j)) # neg value data_var['couplers'] += ' '.join([str(i), str(j), '\n']) data_var['weight'] += ' '.join([str(i), str(j), str(w), '\n']) i, j = n - 1, n - 1 w = -modularity_mat.item((i, j)) # neg value data_var['couplers'] += ' '.join([str(i), str(j), '\n']) data_var['weight'] += ' '.join([str(i), str(j), str(w), '\n']) for i in range(n): data_var['nodes'] += str(i) + '\n' data_var['bias'] += str(i) + ' 0\n' # no bias in modularity data_var['nodes'] += ';\n' data_var['bias'] += ';\n' data_var['weight'] += ';\n' data_var['couplers'] += ';\n' for item in data_var: mygraphfile.write(data_var[item])
def modularity_spectrum(G): """Return eigenvalues of the modularity matrix of G. Parameters ---------- G : Graph A NetworkX Graph or DiGraph Returns ------- evals : NumPy array Eigenvalues See Also -------- modularity_matrix References ---------- .. [1] M. E. J. Newman, "Modularity and community structure in networks", Proc. Natl. Acad. Sci. USA, vol. 103, pp. 8577-8582, 2006. """ from scipy.linalg import eigvals if G.is_directed(): return eigvals(nx.directed_modularity_matrix(G)) else: return eigvals(nx.modularity_matrix(G))
def create_two_clusters(graph): nodes = sorted(graph.nodes()) modularity_matrix = nx.modularity_matrix(graph, nodes) eigenvalues, eigenvectors = np.linalg.eigh(modularity_matrix) clusters, centroids = clustering.kmeans(eigenvectors[-2:].getT(), 2) labels, dist = clustering.vq(eigenvectors[0:2].getT(), clusters) return labels
def get_sub_mod_matrix(graph, ptn_variables): B_matrix = nx.modularity_matrix(graph, nodelist=sorted(graph.nodes())) free_var = [] fixed_var = [] fixed_vec = [] free_nodes = [] fixed_nodes = [] for node in sorted(ptn_variables): if ptn_variables[node] == 'free': free_var.append(True) fixed_var.append(False) free_nodes.append(node) else: free_var.append(False) fixed_var.append(True) fixed_vec.append(ptn_variables[node]) fixed_nodes.append(node) free_var = np.array(free_var) sub_B_matrix = B_matrix[free_var][:, free_var] bias = [] for node_i in free_nodes: bias_i = 0 for node_j in fixed_nodes: s_j = ptn_variables[node_j] bias_i += 2 * s_j * B_matrix.item((node_i, node_j)) bias.append(bias_i) fixed_var = np.array(fixed_var) C = B_matrix[fixed_var][:, fixed_var] n = C.shape[0] vec = np.array(fixed_vec).reshape(n, 1) constant = vec.transpose() * C * vec return sub_B_matrix, bias, constant.item(0)
def get_base_modularity_matrix(network): ''' Obtain the modularity matrix for the whole network Parameters ---------- network : nx.Graph or nx.DiGraph The network of interest Returns ------- np.matrix The modularity matrix for `network` Raises ------ TypeError When the input `network` does not fit either nx.Graph or nx.DiGraph ''' if type(network) == nx.Graph: return sparse.csc_matrix(nx.modularity_matrix(network)) elif type(network) == nx.DiGraph: return sparse.csc_matrix(nx.directed_modularity_matrix(network)) else: raise TypeError( 'Graph type not supported. Use either nx.Graph or nx.Digraph')
def test_modularity_sv(self): w = np.array([[0, 1, 1, 0, 0, 0], [1, 0, 1, 0, 0, 0], [1, 1, 0, 1, 0, 0], [0, 0, 1, 0, 1, 1], [0, 0, 0, 1, 0, 1], [0, 0, 0, 1, 1, 0]]) G = nx.from_numpy_matrix(w) B = nx.modularity_matrix(G, nodelist=list(range(6))) m = G.number_of_edges() mod_obj = partial(modularity_obj, N=1, B=B, m=m) varopt = VariationalQuantumOptimizerSequential( mod_obj, 'SequentialOptimizer', optimizer_parameters=self.optimizer_parameters, varform_description={ 'name': 'RYRZ', 'num_qubits': 6, 'depth': 3, 'entanglement': 'linear' }, backend_description={ 'package': 'qiskit', 'provider': 'Aer', 'name': 'statevector_simulator' }, execute_parameters=self.execute_parameters) varopt.optimize() res = varopt.get_optimal_solution(shots=10000) self.assertTrue( np.array_equal(res[1], np.array([0, 0, 0, 1, 1, 1])) or np.array_equal(res[1], np.array([1, 1, 1, 0, 0, 0])))
def test_modularity_weight(self): "Modularity matrix with weights" # fmt: off B = np.array([[-1.125, 0.25, 0.25, 0.625, 0.], [0.25, -0.5, 0.5, -0.25, 0.], [0.25, 0.5, -0.5, -0.25, 0.], [0.625, -0.25, -0.25, -0.125, 0.], [0., 0., 0., 0., 0.]]) # fmt: on G_weighted = self.G.copy() for n1, n2 in G_weighted.edges(): G_weighted.edges[n1, n2]["weight"] = 0.5 # The following test would fail in networkx 1.1 np.testing.assert_equal(nx.modularity_matrix(G_weighted), B) # The following test that the modularity matrix get rescaled accordingly np.testing.assert_equal( nx.modularity_matrix(G_weighted, weight="weight"), 0.5 * B)
def _func(sub_nodes): print "Calculating modularity matrix and it's eigs ..." mm = nx.modularity_matrix(G.subgraph(sub_nodes)) vals, vecs = scipy.linalg.eigh(mm) count = vecs.shape[1] vecs = np.flip(vecs, -1) ub = max(min(math.ceil(count / 2.0), 30), 1) return vecs[:, :int(ub)] # our method!
def get_data_from(G): print "Calculating modularity matrix and it's eigs ..." mm = nx.modularity_matrix(G) vals, vecs = scipy.linalg.eigh(mm) print "Done" vecs = np.flip(vecs, -1) ub = 10 return vecs[:, :int(ub)] # our method!
def get_base_modularity_matrix(network): if type(network) == nx.Graph: return sparse.csc_matrix(nx.modularity_matrix(network)) elif type(network) == nx.DiGraph: return sparse.csc_matrix(nx.directed_modularity_matrix(network)) else: raise TypeError( 'Graph type not supported. Use either nx.Graph or nx.Digraph')
def get_erdos_renyi_graph(left, right, p=0.7, seed=42, **kwargs): right = int(right) # kwargs are ignored if left != right: warnings.warn("Ignoring right parameter") print("Generating Erdos-Renyi graph on {} vertices with p={} and seed={}" .format(left, p, seed)) G = nx.erdos_renyi_graph(left, p, seed=seed) B = nx.modularity_matrix(G).A return G, None
def spectral_comunities(G): mod_matrix = nx.modularity_matrix(G) values, vectors = linalg.eig(mod_matrix) max_index = 0 for x in range(2, len(values)): if values[x] > values[max_index]: max_index = x eigenvector = vectors[max_index].tolist() eigenvector = eigenvector[0] sList = [1 if val > 0 else -1 for val in eigenvector] return sList
def get_optimal_modularity_bitstring(G): # Guaranteed to return a string of +1 / -1 B = nx.modularity_matrix(G).A _, bitstring = optimize_modularity(G, B) if 0 in bitstring: # assuming bitstring is of zeros and ones bitstring = [ -1 if x == 0 else 1 if x == 1 else 'Error' for x in bitstring ] if 'Error' in bitstring or len(bitstring) != G.number_of_nodes(): raise ValueError("Incorrect bistring returned by nx.erdos_renyi_graph") return bitstring
def networkX_modularity(adj_graph,sym,weight='weight'): # Compute the modularity matrix using NetworkX built in function. # # Can take symmetric or directed graphs (sym='sym' or sym=''). # Can take weighted or unweighted graphs (weight='weight' or weight=None). # if (sym=='sym'): B = nx.modularity_matrix(adj_graph,weight=weight) else: B = nx.directed_modularity_matrix(adj_graph,weight=weight) return B
def fit(self, graph: nx.classes.graph.Graph): """ Fitting a Social Dimensions model. Arg types: * **graph** *(NetworkX graph)* - The graph to be embedded. """ self._set_seed() self._check_graph(graph) number_of_nodes = graph.number_of_nodes() L_tilde = nx.modularity_matrix(graph, nodelist=range(number_of_nodes)) _, self._embedding = sps.linalg.eigsh(L_tilde, k=self.dimensions, which='LM', return_eigenvectors=True)
def test_modularity_obj(self): w = np.array([[0, 1, 1, 0, 0, 0], [1, 0, 1, 0, 0, 0], [1, 1, 0, 1, 0, 0], [0, 0, 1, 0, 1, 1], [0, 0, 0, 1, 0, 1], [0, 0, 0, 1, 1, 0]]) G = nx.from_numpy_matrix(w) B = nx.modularity_matrix(G, nodelist=list(range(6))) m = G.number_of_edges() x = np.array([0, 0, 0, 1, 1, 1]) N = 1 y = np.array([0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1]) M = 2 self.assertTrue(abs(modularity_obj(x, N, B, m) + 10 / 28) < 1e-5) self.assertTrue(abs(modularity_obj(y, M, B, m) + 9 / 98) < 1e-5)
def main2(): """ spectral same part""" method = 'pyomo' if method == 'dwave': solver = start_sapi() embedding = get_native_embedding(solver) num_reads = 1000 annealing_time = 200 #seed = random.randint(1,10000) #seed = 8834 #print seed random.seed(seed) filename = sys.argv[1] graph = data_to_graph(filename) #print '%i nodes, %i edges' %(nx.number_of_nodes(graph), nx.number_of_edges(graph)) mod_matrix = nx.modularity_matrix(graph, nodelist=sorted(graph.nodes())) nnodes = nx.number_of_nodes(graph) hardware_size = 25 ptn = [1 - 2 * random.randint(0, 1) for _ in range(nnodes)] #init_ptn = [1 for _ in range(nnodes)] #init_ptn = [np.sign(i) for i in nx.fiedler_vector(graph).tolist()] mod = compute_modularity(graph, mod_matrix, ptn) #print 'init modularity:', mod, 0.25*mod/nx.number_of_edges(graph) ptn_variables = {} for node in sorted(graph.nodes()): ptn_variables[node] = ptn[node] sp_order = nx.spectral_ordering(graph) for mynode in sorted(graph.nodes()): free_nodes = spectral_neigh_same_part(mynode, graph, mod_matrix, ptn, hardware_size, sp_order) for node in free_nodes: ptn_variables[node] = 'free' if method == 'dwave': new_ptn = sapi_refine_modularity(graph, solver, hardware_size, ptn_variables, num_reads, annealing_time, embedding) else: new_ptn = pyomo_refine(graph, ptn_variables) for node in free_nodes: ptn_variables[node] = new_ptn[node] mod = compute_modularity(graph, mod_matrix, new_ptn)
def get_modularity(graph): #graphfile = folder + sys.argv[1] #graph = nx.read_graphml(graphfile, node_type=int) instance = minimize_ising_model.model.create_instance("neg_modularity.dat") solver = SolverFactory("gurobi") #solver_manager = SolverManagerFactory('neos') # For Neos server # cplex options #solver.options['parallel'] = -1 # gurobi options solver.options['threads'] = min(16, multiprocessing.cpu_count()) #solver.options['timelimit'] = 10 #results = solver_manager.solve(instance, opt=solver, tee=True) # Neos server results = solver.solve(instance, tee=True) energy = instance.min_ising() solver_modularity = -0.25 * energy / nx.number_of_edges(graph) unscaled = -energy # Get partition varobject = getattr(instance, 'x') part0 = [] part1 = [] ising_partition = ['unset' for i in graph.nodes()] for index in sorted(varobject): if varobject[index].value > 0.001: part1.append(index) ising_partition[index] = 1 else: ising_partition[index] = -1 part0.append(index) #print(ising_partition) mod_matrix = nx.modularity_matrix(graph) mymod = compute_modularity(graph, mod_matrix, ising_partition) res = { 'unscaled': unscaled, 'solver_modularity': solver_modularity, 'from_part': mymod } print('unscaled:', res['unscaled']) print("Solver Modularity:", res['solver_modularity']) print("Modularity from part:", res['from_part']) return res
def get_obj_val(graph_generator_name, left, right, seed=None, obj_params='ndarray', sign=1, backend='IBMQX', backend_params={'depth': 3}, return_x=False): # Generate the graph G, _ = generate_graph(graph_generator_name, left, right, seed=seed) B = nx.modularity_matrix(G).A return get_obj(G.number_of_nodes(), B, obj_params=obj_params, sign=sign, backend=backend, backend_params=backend_params, return_x=return_x)
G= nx.Graph() zz_=np.delete(zz,[2],axis=1) zzTotal_list = zz_.tolist() #N = G.add_nodes_from(TotalCellsRoi) E = G.add_edges_from(zzTotal_list) Nnodos = nx.number_of_nodes(G) Density = nx.density(G) Cluster = nx.average_clustering(G) Assortativity = nx.degree_assortativity_coefficient(G) ShortPath = nx.average_shortest_path_length(G) nx.modularity_matrix(G) #Attracting = nx.is_attracting_component(G) plt.style.use('seaborn-whitegrid') nx.draw(G,node_size=100,node_color='tomato',edge_color='gray') #%% #### AGRUPACION Y COMUNIDADES DE GRAFOS POR METODO gIRVAN community=[] def edge_to_remove(G): dict1=nx.edge_betweenness_centrality(G) list_of_tuples = dict1.items()
def modularity_matrix_calc(self, graph): """ This function calculates the modularity matrix""" return networkx.modularity_matrix(graph)
def test_angles(graph_generator_name, left, right, angles, seed=None, verbose=0, compute_optimal=False, backend='IBMQX', backend_params={ 'backend_device': None, 'depth': 3 }): # note that compute optimal uses brute force! Not recommended for medium and large problem # angles should be a dictionary with fields 'beta' and 'gamma', e.g. {'beta': 2.0541782343349086, 'gamma': 0.34703642333837853} rand_seed = seed # Generate the graph G, _ = generate_graph(graph_generator_name, left, right, seed=seed) # Use angles # Using NetworkX modularity matrix B = nx.modularity_matrix(G).A # Compute ideal cost if compute_optimal: optimal_modularity = gm.compute_modularity(G, B, solution_bitstring) print("Optimal solution energy: ", optimal_modularity) else: optimal_modularity = None if backend == 'IBMQX': if not isinstance(angles, (np.ndarray, np.generic, list)): raise ValueError( "Incorrect angles received: {} for backend {}".format( angles, backend)) var_form = IBMQXVarForm(num_qubits=G.number_of_nodes(), depth=backend_params['depth']) resstrs = var_form.run(angles) else: raise ValueError("Unsupported backend: {}".format(backend)) if verbose > 1: # print distribution allstrs = list(product([0, 1], repeat=len(qubits))) freq = {} for bitstr in allstrs: freq[str(list(bitstr))] = 0 for resstr in resstrs: resstr = str(list(resstr)) # for it to be hashable if resstr in freq.keys(): freq[resstr] += 1 else: raise ValueError( "received incorrect string: {}".format(resstr)) for k, v in freq.items(): print("{} : {}".format(k, v)) # Raw results modularities = [gm.compute_modularity(G, B, x) for x in resstrs] mod_max = max(modularities) # Probability of getting best modularity if compute_optimal: mod_pmax = float(np.sum(np.isclose( modularities, optimal_modularity))) / float(len(modularities)) else: mod_pmax = None mod_mean = np.mean(modularities) if verbose: print("Best modularity found:", mod_max) print("pmax: ", mod_pmax) print("mean: ", mod_mean) return { 'max': mod_max, 'mean': mod_mean, 'pmax': mod_pmax, 'optimal': optimal_modularity, 'x': angles }
def test_mpo_objective_modularity_k_way(self): import logging logging.disable(logging.CRITICAL) import matlab G = nx.OrderedGraph() elist = [(0, 2), (0, 3), (0, 11), (1, 2), (1, 3), (2, 3), (3, 4), (4, 6), (4, 7), (5, 6), (5, 7), (6, 7), (7, 8), (8, 10), (8, 11), (9, 10), (9, 11), (10, 11)] G.add_edges_from(elist) nnodes = G.number_of_nodes() N = 2 nqubits = nnodes * N # N variables per node -- up to 2**N communities node_list = list(range(nnodes)) B = matlab.double(nx.modularity_matrix(G, nodelist=node_list).tolist()) obj = partial(modularity_energy, N=N, B=nx.modularity_matrix(G, nodelist=node_list).getA(), m=G.number_of_edges(), deg_list=[G.degree[i] for i in node_list]) precomputed_good_params = np.array([ 4.15610651, 1.31952566, 5.39528713, 0.03165722, 0.29017244, 1.13614827, -2.07509482, 2.29757058, 0.41243041, 5.76625946, -4.32125694, -2.21142374, -2.95591283, -0.44569759, 5.00991472, -2.38284874, 4.08231081, 1.55265289, -5.20439166, -2.62705216, 0.26832527, -4.12101477, -4.27473955, 4.58479753, -1.56014587, -0.52379135, -2.78755743, 6.35824237, 6.16095312, -4.80030703, -0.84348438, -2.9339378, -3.13894666, 3.30636124, -3.2208338, -4.00239323, 1.91003078, 5.73582487, 1.4899889, 5.80934756, 3.10322086, 1.60227976, 4.74931798, 2.32907816, 4.38702652, -4.80603026, -0.82120823, -3.2610527, -3.64614703, 5.99653502, 4.94231979, 3.73974001, -2.34897493, -4.71583219, 1.48330405, 6.04077852, 2.84132271, 0.01466078, -3.61453391, -5.68864954, 6.08686394, 5.46570721, 5.44826073, -5.26395504, -0.93564532, 1.89588868, -5.21973893, 3.01863335, 2.51588271, -3.97664614, 7.58394176, -3.59918101, 0.96797456, -0.74624669, -4.83039533, -4.03002175, 0.70923642, -3.75009256, 4.82231404, -4.22920321, -3.52680223, 0.31700832, 6.75879683, 3.50625919, -5.1009759, 3.0347534, -4.09756222, -3.42942231, 2.83041522, -3.9895508, -2.8693705, 2.12212776, 0.39196109, 7.48359308, -3.69241341, -3.46325887, -2.33739302, -5.40617378, 3.54184289, 4.31628083, 0.29044417, 4.18564356, 2.30074315, 2.57942552, -3.10036929, -4.30000567, -1.62644728, 5.24134547, -1.74320921, 3.27039832, 4.08539243, 4.56899165, 5.74862203, -2.40435231, 3.44914951, -5.03919062, 2.84952808, -1.13341506, 5.00855887, -5.66899901, 0.28431306, -4.32562784, 2.91942835, 5.01386366, 0.36082722, 7.66761106, 4.13723874, -4.45246101, 0.13413378, 5.94874616, 5.92336011, 6.59555163, -3.31464691, 2.2468367, -4.56588791, 1.01536706, 0.34020607, 3.74764888, 1.65250476, -4.72223208, 2.38389989, -6.36721914, -2.80402566, -4.48821116, 0.28952596, -4.51485203, 3.08119184, -0.60249566, 6.10183681, 5.66230155, 0.30292948, 2.08435297, 2.48144112, -0.4033077, 3.18158093, 4.38631354, -1.37507408, -0.72594662, -3.35534963, -0.09028156, -5.56034943, 3.40867727, 2.51204148, -3.50149819, 3.21263761, 1.39083258, -0.3292894, -2.45686952, -4.17826603, -3.08442966, -2.04319878, 1.13819382, -2.12785284, -0.62048513, -3.67792066, 5.43649767, -3.14400277, 3.01728892, -0.62765206, -1.6561974, 4.61813977, 5.65717505, 2.8793227, 0.67725344, 3.29505459, 0.33112227, 3.07787261, -2.43315426, -1.11027068, 3.18688124, 2.95611302, -1.09703103 ]) varopt = VariationalQuantumOptimizerSequential( obj, 'COBYLA', optimizer_parameters={'maxiter': 5}, initial_point=precomputed_good_params, varform_description={ 'package': 'mpsbackend', 'name': 'RYRZ', 'num_qubits': nqubits, 'depth': 3, 'entanglement_gate': 'cz' }, backend_description=self.backend_description, objective_parameters={ 'use_mpo_energy': True, 'hamiltonian_constructor': 'construct_k_way_modularity_Hamiltonian', 'hamiltonian_constructor_parameters': [B, N] }, execute_parameters={}) optres = varopt.optimize() self.assertTrue(optres['min_val'] < -19) logging.disable(logging.NOTSET)
def load_dataset(name): dolphin_path = 'Datasets/dolphins.gml' adjnoun_path = "Datasets/adjnoun.gml" football_path = 'Datasets/football.gml' polbooks_path = 'Datasets/polbooks.gml' email_edges = 'Datasets/email-Eu-core.txt' email_labels = 'Datasets/email-Eu-core-department-labels.txt' # # Polblogs # if(name=='polblogs'): # G_data = nx.read_gml(polblogs_path) # G_data = G_data.to_undirected() # G_data = nx.Graph(G_data) # B_data = nx.modularity_matrix(G_data) # Karate if(name == 'karate'): G_data = nx.karate_club_graph() B_data = nx.modularity_matrix(G_data) # Football elif(name == 'football'): G_data = nx.read_gml(football_path) B_data = nx.modularity_matrix(G_data) # Polbooks elif(name == 'polbooks'): G_data = nx.read_gml(polbooks_path) B_data = nx.modularity_matrix(G_data) # Dolphin elif(name == 'dolphin'): G_data = nx.read_gml(dolphin_path) B_data = nx.modularity_matrix(G_data) # lfr 0.1 elif(name == 'lfr 0.1'): G_data = nx.Graph() data, labels = load_data(0.1) for index, item in enumerate(labels): G_data.add_node(index+1, value=item) for item in data: G_data.add_edge(*item) B_data = nx.modularity_matrix(G_data) # lfr 0.3 elif(name == 'lfr 0.3'): G_data = nx.Graph() data, labels = load_data(0.3) for index, item in enumerate(labels): G_data.add_node(index+1, value=item) for item in data: G_data.add_edge(*item) B_data = nx.modularity_matrix(G_data) # lfr 0.5 elif(name == 'lfr 0.5'): G_data = nx.Graph() data, labels = load_data(0.5) for index, item in enumerate(labels): G_data.add_node(index+1, value=item) for item in data: G_data.add_edge(*item) B_data = nx.modularity_matrix(G_data) elif(name == 'email'): G_data=nx.Graph() with open(email_edges) as f: for line in f: if(len(line)>0): x=(line.split()) G_data.add_edge(int(x[0]),int(x[1])) G_data.remove_nodes_from([658,653,648,798,731,772,670,691,675,684,660,711,744,808,746,580,633,732,703]) B_data = nx.modularity_matrix(G_data) return G_data, B_data
ajModList.append([]) for xj in range(len(clusterL[xi])): for xk in range(len(clusterL[xi])): if clusterL[xi][xj] != clusterL[xi][xk]: ajModList.append((clusterL[xi][xj], clusterL[xi][xk])) adjac_matrix[clusterL[xi][xj]][clusterL[xi][xk]] = 1 # adjac matrix #2 # combine every node like shown on graph adjac_matrix2 = np.zeros((len(Data) + len(Z), len(Data) + len(Z)), dtype=int) for nodex in az: adjac_matrix2[nodex] = 1 G1 = nx.from_numpy_matrix(adjac_matrix) B1 = nx.modularity_matrix(G1) G2 = nx.from_numpy_matrix(adjac_matrix2) B2 = nx.modularity_matrix(G2) ajModScore = [] for am in range(len(ajModList)): if ajModList[am] == []: continue ajModScore.append(ajModList[am]) # Creating adjac matrix adjac_matrix3 = np.zeros((len(Data) + len(Z), len(Data) + len(Z)), dtype=int) # adjac matrix #1