def test_encode_decode_adj(): ######## code test ########### G = nx.ladder_graph(5) G = nx.grid_2d_graph(20, 20) G = nx.ladder_graph(200) G = nx.karate_club_graph() G = nx.connected_caveman_graph(2, 3) print(G.number_of_nodes()) adj = np.asarray(nx.to_numpy_matrix(G)) G = nx.from_numpy_matrix(adj) # start_idx = np.random.randint(adj.shape[0]) x_idx = np.array(bfs_seq(G, start_idx)) adj = adj[np.ix_(x_idx, x_idx)] print("adj\n", adj) adj_output = encode_adj(adj, max_prev_node=5) print("adj_output\n", adj_output) adj_recover = decode_adj(adj_output, max_prev_node=5) print("adj_recover\n", adj_recover) print("error\n", np.amin(adj_recover - adj), np.amax(adj_recover - adj)) adj_output = encode_adj_flexible(adj) for i in range(len(adj_output)): print(len(adj_output[i])) adj_recover = decode_adj_flexible(adj_output) print(adj_recover) print(np.amin(adj_recover - adj), np.amax(adj_recover - adj))
def classic_graphs(): print("Balanced Tree") BG = nx.balanced_tree(3, 2) draw_graph(BG) print("Barbell Graph") BBG = nx.barbell_graph(3, 2) draw_graph(BBG) print("Complete Graph") CG = nx.complete_graph(10) draw_graph(CG) print("Complete Multipartite Graph") CMG = nx.complete_multipartite_graph(1, 2, 10) print([CMG.node[u]['block'] for u in CMG]) print(CMG.edges(0)) print(CMG.edges(2)) print(CMG.edges(4)) draw_graph(CMG) print("Circular Ladder Graph") CLG = nx.circular_ladder_graph(5) draw_graph(CLG) print("Dorogovtsev Goltsev Mendes Graph") DGMG = nx.dorogovtsev_goltsev_mendes_graph(3) draw_graph(DGMG) print("Empty Graph") EG = nx.empty_graph(5, create_using=nx.DiGraph()) draw_graph(EG) print("Grid 2D Graph") G2DG = nx.grid_2d_graph(5, 6) draw_graph(G2DG) print("Grid Graph") GDG = nx.grid_graph(dim=[5, 2]) draw_graph(GDG) print("Hypercube Graph") HG = nx.hypercube_graph(3) draw_graph(HG) print("Ladder Graph") LG = nx.ladder_graph(8) draw_graph(LG) print("Ladder Graph") LG = nx.ladder_graph(8) draw_graph(LG) print("Lollipop Graph") LPG = nx.lollipop_graph(n=6, m=4) draw_graph(LPG) print("Null Graph") NG = nx.null_graph() draw_graph(NG) print("Path Graph") PG = nx.path_graph(16) draw_graph(PG) print("Star Graph") SG = nx.star_graph(16) draw_graph(SG) print("Trivial Graph") TG = nx.trivial_graph() draw_graph(TG) print("Wheel Graph") WG = nx.wheel_graph(n=18) draw_graph(WG)
def test_ladder_graph(self): for i, G in [(0, nx.empty_graph(0)), (1, nx.path_graph(2)), (2, nx.hypercube_graph(2)), (10, nx.grid_graph([2, 10]))]: assert is_isomorphic(nx.ladder_graph(i), G) pytest.raises(nx.NetworkXError, nx.ladder_graph, 2, create_using=nx.DiGraph) g = nx.ladder_graph(2) mg = nx.ladder_graph(2, create_using=nx.MultiGraph) assert_edges_equal(mg.edges(), g.edges())
def main(): args = parse_arguments() # Generate graph for given parameters if args.cycle: graph = networkx.cycle_graph(args.vertices) graph = networkx.path_graph(args.vertices) elif args.star: graph = networkx.star_graph(args.vertices) elif args.wheel: graph = networkx.wheel_graph(args.vertices) elif args.ladder: graph = networkx.ladder_graph(args.vertices) elif args.fill_rate: if args.fill_rate > 50.0: graph = networkx.gnp_random_graph(args.vertices, args.fill_rate / 100.0, None, args.directed) else: graph = networkx.fast_gnp_random_graph(args.vertices, args.fill_rate / 100.0, None, args.directed) else: graph = networkx.gnm_random_graph(args.vertices, args.edges, None, args.directed) # Print generated graph print("{} {}".format(graph.number_of_nodes(), graph.number_of_edges())) for edge in graph.edges(): print("{} {}".format(edge[0] + 1, edge[1] + 1)) # Export generated graph to .png if args.image_path: export_to_png(graph, args.image_path)
def test_3_ladder(self): """Test fault-tolerance of a complete ladder graph n=3""" stack_roots = {i: 1 for i in range(self.NUM_DPS // 2)} dp_links = FaucetTopoGenerator.dp_links_networkx_graph( networkx.ladder_graph(self.NUM_DPS // 2)) self.set_up(self.NUM_DPS, self.NUM_VLANS, dp_links, stack_roots) self.network_function()
class GraphType: BALANCED_TREE = ('Balanced tree', _balanced_tree) BARBELL = ('Barbell', lambda n: nx.barbell_graph(int(n*.4), int(n*.3))) CIRCULAR_LADDER = ('Circular ladder', lambda n: nx.circular_ladder_graph(int(n/2))) COMPLETE = ('Complete', lambda n: nx.complete_graph(int(n))) COMPLETE_BIPARTITE = ('Complete bipartite', lambda n: nx.complete_bipartite_graph(int(n*.6), int(n*.4))) CYCLE = ('Cycle', lambda n: nx.cycle_graph(int(n))) GRID = ('Grid', lambda n: nx.grid_graph([int(np.sqrt(n))]*2)) HYPERCUBE = ('Hypercube', _hypercube) LADDER = ('Ladder', lambda n: nx.ladder_graph(int(n/2))) LOBSTER = ('Lobster', lambda n: nx.random_lobster(int(n / (1 + .7 + .7*.5)), .7, .5)) LOLLIPOP = ('Lollipop', lambda n: nx.lollipop_graph(int(n/2), int(n/2))) PATH = ('Path', lambda n: nx.path_graph(int(n))) REGULAR = ('Regular', lambda n: nx.random_regular_graph(np.random.randint(10)*2, n)) SCALEFREE = ('Scale-free', lambda n: nx.scale_free_graph(int(n))) SHELL = ('Shell', lambda n: nx.random_shell_graph([(int(n*.1), int(n*.1), .2), (int(n*.3), int(n*.3), .8), (int(n*.6), int(n*.6), .5)])) STAR = ('Star', lambda n: nx.star_graph(int(n - 1))) WAXMAN = ('Waxman', lambda n: nx.waxman_graph(int(n))) WHEEL = ('Wheel', lambda n: nx.wheel_graph(int(n))) all = (BALANCED_TREE, BARBELL, CIRCULAR_LADDER, COMPLETE, COMPLETE_BIPARTITE, CYCLE, GRID, HYPERCUBE, LADDER, LOBSTER, LOLLIPOP, PATH, REGULAR, SCALEFREE, SHELL, STAR, WAXMAN, WHEEL)
def generate_topology(self, topo_type, node_count, branches = None): if topo_type == TopologyType.LADDER: total_nodes = node_count/2 graph = networkx.ladder_graph(total_nodes) elif topo_type == TopologyType.LINEAR: graph = networkx.path_graph(node_count) elif topo_type == TopologyType.MESH: graph = networkx.complete_graph(node_count) elif topo_type == TopologyType.TREE: h = math.log(node_count + 1)/math.log(2) - 1 graph = networkx.balanced_tree(2, h) elif topo_type == TopologyType.STAR: graph = networkx.Graph() graph.add_node(0) nodesinbranch = (node_count - 1)/ BRANCHES c = 1 for i in xrange(BRANCHES): prev = 0 for n in xrange(1, nodesinbranch + 1): graph.add_node(c) graph.add_edge(prev, c) prev = c c += 1 return graph
def generate_topology(self, topo_type, node_count, branches=None): if topo_type == TopologyType.LADDER: total_nodes = node_count / 2 graph = networkx.ladder_graph(total_nodes) elif topo_type == TopologyType.LINEAR: graph = networkx.path_graph(node_count) elif topo_type == TopologyType.MESH: graph = networkx.complete_graph(node_count) elif topo_type == TopologyType.TREE: h = math.log(node_count + 1) / math.log(2) - 1 graph = networkx.balanced_tree(2, h) elif topo_type == TopologyType.STAR: graph = networkx.Graph() graph.add_node(0) nodesinbranch = (node_count - 1) / BRANCHES c = 1 for i in xrange(BRANCHES): prev = 0 for n in xrange(1, nodesinbranch + 1): graph.add_node(c) graph.add_edge(prev, c) prev = c c += 1 return graph
def ladder(N): """ Creates a ladder graph of N nodes: two rows of N/2 nodes, with each pair connected by a single edge. In case N is odd another node is attached to the first one. """ G = nx.ladder_graph(N // 2) if N % 2 != 0: G.add_node(N - 1) G.add_edge(0, N - 1) return G
def generate_ladder_graph( length_of_ladder: int, weight_sampler: Sampler = constant_sampler(1.0), seed: Optional[int] = None, ) -> nx.Graph: graph = nx.ladder_graph(length_of_ladder) _weight_graph_edges(graph, weight_sampler, seed) return graph
def generate_struct_mask(struct, n_nodes, shuffle_nodes): # a horrible collection of ifs due to args in nx constructors if struct == "star": g = nx.star_graph(n_nodes) elif struct == "random_tree": g = nx.random_tree(n_nodes) elif struct == "powerlaw_tree": g = nx.powerlaw_tree(n_nodes, gamma=3, seed=None) elif struct == "binary_tree": raise NotImplementedError("Implement a binary tree.") elif struct == "path": g = nx.path_graph(n_nodes) elif struct == "cycle": g = nx.cycle_graph(n_nodes) elif struct == "ladder": g = nx.ladder_graph(n_nodes) elif struct == "grid": m = np.random.choice(range(1, n_nodes+1)) n = n_nodes // m g = nx.grid_2d_graph(m, n) elif struct == "circ_ladder": g = nx.circular_ladder_graph(n_nodes) elif struct == "barbell": assert n_nodes >= 4 m = np.random.choice(range(2, n_nodes-1)) blocks = (m, n_nodes-m) g = nx.barbell_graph(*blocks) elif struct == "loll": assert n_nodes >= 2 m = np.random.choice(range(2, n_nodes+1)) g = nx.lollipop_graph(m, n_nodes-m) elif struct == "wheel": g = nx.wheel_graph(n_nodes) elif struct == "bipart": m = np.random.choice(range(n_nodes)) blocks = (m, n_nodes-m) g = nx.complete_multipartite_graph(*blocks) elif struct == "tripart": # allowed to be zero m, M = np.random.choice(range(n_nodes), size=2) if m > M: m, M = M, m blocks = (m, M-m, n_nodes-M) g = nx.complete_multipartite_graph(*blocks) elif struct == "fc": g = nx.complete_graph(n_nodes) else: raise NotImplementedError("Structure {} not implemented yet.".format(struct)) node_order = list(range(n_nodes)) if shuffle_nodes: np.random.shuffle(node_order) # a weird subclass by default; raises a deprecation warning # with a new update of networkx, this should be updated to # nx.convert_matrix.to_numpy_array np_arr_g = nx.to_numpy_matrix(g, nodelist=node_order) return np_arr_g.astype(int)
def mock_get_local_network(): """Return a mock neighborhood of the specified word.""" word = flask.request.args.get('word') if word is None: return response_graph = nx.ladder_graph(random.randint(0, 22)) response = nx.readwrite.json_graph.node_link_data(response_graph) return flask.jsonify(response)
def create_graph(topology, info): if topology == 'simple': return nx.barabasi_albert_graph(info['num_nodes'], info['avg_degree']) elif topology == 'star': return nx.star_graph(info['num_nodes']) elif topology == 'tree': return nx.random_tree(info['num_nodes']) elif topology == 'ladder': return nx.ladder_graph(round(info['num_nodes'] / 2)) else: print("Invalid network style received. Aborting...") exit(1)
def main(): global paths print("test heuristic!") for AppGraph1 in [ nx.complete_graph(400), nx.ladder_graph(4), nx.complete_graph(4), ]: for Substrate in [ nx.ladder_graph(4), nx.complete_graph(4), nx.complete_graph(300) ]: AppGraph2 = nx.ladder_graph(4) for v in AppGraph1.nodes(): AppGraph1.node[v]['weight'] = 2 for e in AppGraph1.edges(): AppGraph1[e[0]][e[1]]['weight'] = 2 AppGraph1.node[0]['weight'] = 3 for v in AppGraph2.nodes(): AppGraph2.node[v]['weight'] = 2 for e in AppGraph2.edges(): AppGraph2[e[0]][e[1]]['weight'] = 2 AppGraph2.node[0]['weight'] = 3 for v in Substrate.nodes(): Substrate.node[v]['weight'] = 4 Substrate.node[v]['free'] = 4 for e in Substrate.edges(): Substrate[e[0]][e[1]]['weight'] = 4 Substrate[e[0]][e[1]]['free'] = 4 gba = GreedyBorderAllocationForFogModel(None, None) result = gba.greedyBorderAllocation([AppGraph1, AppGraph2], Substrate, {}) if result != None and not gba.feasibility(AppGraph1, Substrate, result): print("problem") print("try next") print("done")
def create_graph(topology, info): """Create a graph depending on the information in the info struct provided. """ if topology == 'simple': return nx.barabasi_albert_graph(info['num_nodes'], info['avg_degree']) elif topology == 'star': return nx.star_graph(info['num_nodes']) elif topology == 'tree': return nx.random_tree(info['num_nodes']) elif topology == 'ladder': return nx.ladder_graph(int(round(info['num_nodes'] / 2))) else: print("Invalid network style received. Aborting...") exit(1)
def LadderGraph(n): """ Returns a ladder graph with 2\*n nodes. A ladder graph is a basic structure that is typically displayed as a ladder, i.e.: two parallel path graphs connected at each corresponding node pair. This constructor depends on NetworkX numeric labels. PLOTTING: Upon construction, the position dictionary is filled to override the spring-layout algorithm. By convention, each ladder graph will be displayed horizontally, with the first n nodes displayed left to right on the top horizontal line. EXAMPLES: Construct and show a ladder graph with 14 nodes :: sage: g = graphs.LadderGraph(7) sage: g.show() # long time Create several ladder graphs in a Sage graphics array :: sage: g = [] sage: j = [] sage: for i in range(9): ....: k = graphs.LadderGraph(i+2) ....: g.append(k) sage: for i in range(3): ....: n = [] ....: for m in range(3): ....: n.append(g[3*i + m].plot(vertex_size=50, vertex_labels=False)) ....: j.append(n) sage: G = sage.plot.graphics.GraphicsArray(j) sage: G.show() # long time """ pos_dict = {} for i in range(n): pos_dict[i] = (i, 1) for i in range(n, 2 * n): x = i - n pos_dict[i] = (x, 0) import networkx G = networkx.ladder_graph(n) return graph.Graph(G, pos=pos_dict, name="Ladder graph")
def LadderGraph(n): """ Returns a ladder graph with 2\*n nodes. A ladder graph is a basic structure that is typically displayed as a ladder, i.e.: two parallel path graphs connected at each corresponding node pair. This constructor depends on NetworkX numeric labels. PLOTTING: Upon construction, the position dictionary is filled to override the spring-layout algorithm. By convention, each ladder graph will be displayed horizontally, with the first n nodes displayed left to right on the top horizontal line. EXAMPLES: Construct and show a ladder graph with 14 nodes :: sage: g = graphs.LadderGraph(7) sage: g.show() # long time Create several ladder graphs in a Sage graphics array :: sage: g = [] sage: j = [] sage: for i in range(9): ....: k = graphs.LadderGraph(i+2) ....: g.append(k) sage: for i in range(3): ....: n = [] ....: for m in range(3): ....: n.append(g[3*i + m].plot(vertex_size=50, vertex_labels=False)) ....: j.append(n) sage: G = sage.plot.graphics.GraphicsArray(j) sage: G.show() # long time """ pos_dict = {} for i in range(n): pos_dict[i] = (i,1) for i in range(n,2*n): x = i - n pos_dict[i] = (x,0) import networkx G = networkx.ladder_graph(n) return graph.Graph(G, pos=pos_dict, name="Ladder graph")
def make_graph(g_name, n): switcher = { "path": nx.path_graph(n), "complete": nx.complete_graph(n), "binomial tree": nx.binomial_tree(n), "circular ladder": nx.circular_ladder_graph(n), "cycle": nx.cycle_graph(n), "dorogovtsev": nx.dorogovtsev_goltsev_mendes_graph(n), "ladder": nx.ladder_graph(n), "star": nx.star_graph(n), "wheel": nx.wheel_graph(n), "margulis gabber galil": nx.margulis_gabber_galil_graph(n), "chordal cycle": nx.chordal_cycle_graph(n), "hypercube": nx.hypercube_graph(n), "mycielski": nx.mycielski_graph(n) } return switcher.get(g_name)
def test_complete_to_chordal_graph(self): fgrg = nx.fast_gnp_random_graph test_graphs = [ nx.barbell_graph(6, 2), nx.cycle_graph(15), nx.wheel_graph(20), nx.grid_graph([10, 4]), nx.ladder_graph(15), nx.star_graph(5), nx.bull_graph(), fgrg(20, 0.3, seed=1), ] for G in test_graphs: H, a = nx.complete_to_chordal_graph(G) assert nx.is_chordal(H) assert len(a) == H.number_of_nodes() if nx.is_chordal(G): assert G.number_of_edges() == H.number_of_edges() assert set(a.values()) == {0} else: assert len(set(a.values())) == H.number_of_nodes()
def ___test_for_special_graphs(graphs, size): cycle = nx.cycle_graph(size) path = nx.path_graph(size) star = nx.star_graph(size) cycl_ladder = nx.circular_ladder_graph(size) ladder = nx.ladder_graph(size) wheel = nx.wheel_graph(size) cycle_found = False path_found = False star_found = False cycl_ladder_found = False ladder_found = False wheel_found = False # Check if we sampled on of this special graphs for g in graphs: if nx.is_isomorphic(g, cycle): cycle_found = True if nx.is_isomorphic(g, path): path_found = True if nx.is_isomorphic(g, star): star_found = True if nx.is_isomorphic(g, cycl_ladder): cycl_ladder_found = True if nx.is_isomorphic(g, ladder): ladder_found = True if nx.is_isomorphic(g, wheel): wheel_found = True print("Sampled cycle............................{}".format(cycle_found)) print("Sampled path.............................{}".format(path_found)) print("Sampled star.............................{}".format(star_found)) print("Sampled circular ladder..................{}".format( cycl_ladder_found)) print("Sampled ladder...........................{}".format(ladder_found)) print("Sampled wheel............................{}".format(wheel_found)) passed = cycle_found and path_found and star_found and cycl_ladder_found and ladder_found and wheel_found return passed
def test010_ladder_graph(self): """ Large ladder graph. """ g = nx.ladder_graph(1000) mate1 = mv.max_cardinality_matching( g ) mate2 = nx.max_weight_matching( g, True ) self.assertEqual( len(mate1), len(mate2) )
G3T=0 mu=10 sigma=2.5 #Orden logaritmico for logarithmOrder in range(3,5): print('Orden: ',logarithmOrder) log = 2**logarithmOrder ban=True # 3 Metodos de generación distintos G1 = nx.lollipop_graph(log, 2) for e in G1.edges(): G1[e[0]][e[1]]['capacity'] = np.random.normal(mu, sigma) G2 = nx.turan_graph(log, 2) for e in G2.edges(): G2[e[0]][e[1]]['capacity'] = np.random.normal(mu, sigma) G3 = nx.ladder_graph(log) for e in G3.edges(): G3[e[0]][e[1]]['capacity'] = np.random.normal(mu, sigma) for newPair in range(5): print('Pareja: ',newPair) #10 Grafos for graphRepetition in range(10): if ban: ban=False while G1T==G1S: G1S = choice(list(G1.nodes())) G1T = choice(list(G1.nodes())) while G2T==G2S: G2S = choice(list(G2.nodes())) G2T = choice(list(G2.nodes())) while G3T==G3S:
def generate_ladder_graph(length_of_ladder: int, random_weights: bool = False, seed: Optional[int] = None) -> nx.Graph: output_graph = nx.ladder_graph(length_of_ladder) output_graph = weight_graph_edges(output_graph, random_weights, seed) return output_graph
G = nx.complete_graph(50) # this will create a completely connected graph with 50 nodes # %% # plot the graph nx.draw(G) # %% # for demo purpose we plot a few other network types fig, ax = plt.subplots(3, 4, figsize=(15,12)) G = nx.scale_free_graph(50) nx.draw(nx.complete_graph(50), ax=ax[0,0]) nx.draw(nx.star_graph(50), ax=ax[0,1]) nx.draw(nx.circular_ladder_graph(50), ax=ax[0,2]) nx.draw(nx.ladder_graph(50), ax=ax[0,3]) nx.draw(nx.path_graph(50), ax=ax[1,0]) nx.draw(nx.wheel_graph(50), ax=ax[1,1]) nx.draw(nx.erdos_renyi_graph(50, 0.3), ax=ax[1,2]) nx.draw(nx.barabasi_albert_graph(50, 5), ax=ax[1,3]) nx.draw(nx.random_powerlaw_tree(10), ax=ax[2,0]) nx.draw(nx.scale_free_graph(50), ax=ax[2,1]) nx.draw(nx.karate_club_graph(), ax=ax[2,2]) nx.draw(nx.les_miserables_graph(), ax=ax[2,3]) # %% [markdown] # ## Network Statistics # Calculate basic network statistics
def create(args): ### load datasets graphs=[] # synthetic graphs if args.graph_type=='ladder': graphs = [] for i in range(100, 201): graphs.append(nx.ladder_graph(i)) args.max_prev_node = 10 elif args.graph_type=='ladder_small': graphs = [] for i in range(2, 11): graphs.append(nx.ladder_graph(i)) args.max_prev_node = 10 elif args.graph_type=='tree': graphs = [] for i in range(2,5): for j in range(3,5): graphs.append(nx.balanced_tree(i,j)) args.max_prev_node = 256 elif args.graph_type=='caveman': # graphs = [] # for i in range(5,10): # for j in range(5,25): # for k in range(5): # graphs.append(nx.relaxed_caveman_graph(i, j, p=0.1)) graphs = [] for i in range(2, 3): for j in range(30, 81): for k in range(10): graphs.append(caveman_special(i,j, p_edge=0.3)) args.max_prev_node = 100 elif args.graph_type=='caveman_small': # graphs = [] # for i in range(2,5): # for j in range(2,6): # for k in range(10): # graphs.append(nx.relaxed_caveman_graph(i, j, p=0.1)) graphs = [] for i in range(2, 3): for j in range(6, 11): for k in range(20): graphs.append(caveman_special(i, j, p_edge=0.8)) # default 0.8 args.max_prev_node = 20 elif args.graph_type=='caveman_small_single': # graphs = [] # for i in range(2,5): # for j in range(2,6): # for k in range(10): # graphs.append(nx.relaxed_caveman_graph(i, j, p=0.1)) graphs = [] for i in range(2, 3): for j in range(8, 9): for k in range(100): graphs.append(caveman_special(i, j, p_edge=0.5)) args.max_prev_node = 20 elif args.graph_type.startswith('community'): num_communities = int(args.graph_type[-1]) print('Creating dataset with ', num_communities, ' communities') c_sizes = np.random.choice([12, 13, 14, 15, 16, 17], num_communities) #c_sizes = [15] * num_communities for k in range(3000): graphs.append(n_community(c_sizes, p_inter=0.01)) args.max_prev_node = 80 elif args.graph_type=='grid': graphs = [] for i in range(10,20): for j in range(10,20): graphs.append(nx.grid_2d_graph(i,j)) args.max_prev_node = 40 elif args.graph_type=='grid_small': graphs = [] for i in range(2,5): for j in range(2,6): graphs.append(nx.grid_2d_graph(i,j)) args.max_prev_node = 15 elif args.graph_type=='barabasi': graphs = [] for i in range(100,200): for j in range(4,5): for k in range(5): graphs.append(nx.barabasi_albert_graph(i,j)) args.max_prev_node = 130 elif args.graph_type=='barabasi_small': graphs = [] for i in range(4,21): for j in range(3,4): for k in range(10): graphs.append(nx.barabasi_albert_graph(i,j)) args.max_prev_node = 20 elif args.graph_type=='grid_big': graphs = [] for i in range(36, 46): for j in range(36, 46): graphs.append(nx.grid_2d_graph(i, j)) args.max_prev_node = 90 elif 'barabasi_noise' in args.graph_type: graphs = [] for i in range(100,101): for j in range(4,5): for k in range(500): graphs.append(nx.barabasi_albert_graph(i,j)) graphs = perturb_new(graphs,p=args.noise/10.0) args.max_prev_node = 99 # real graphs elif args.graph_type == 'enzymes': graphs= Graph_load_batch(min_num_nodes=10, name='ENZYMES') args.max_prev_node = 25 elif args.graph_type == 'enzymes_small': graphs_raw = Graph_load_batch(min_num_nodes=10, name='ENZYMES') graphs = [] for G in graphs_raw: if G.number_of_nodes()<=20: graphs.append(G) args.max_prev_node = 15 elif args.graph_type == 'protein': graphs = Graph_load_batch(min_num_nodes=20, name='PROTEINS_full') args.max_prev_node = 80 elif args.graph_type == 'DD': graphs = Graph_load_batch(min_num_nodes=100, max_num_nodes=500, name='DD',node_attributes=False,graph_labels=True) args.max_prev_node = 230 elif args.graph_type == 'citeseer': _, _, G = Graph_load(dataset='citeseer') G = max(nx.connected_component_subgraphs(G), key=len) G = nx.convert_node_labels_to_integers(G) graphs = [] for i in range(G.number_of_nodes()): G_ego = nx.ego_graph(G, i, radius=3) if G_ego.number_of_nodes() >= 50 and (G_ego.number_of_nodes() <= 400): graphs.append(G_ego) args.max_prev_node = 250 elif args.graph_type == 'citeseer_small': _, _, G = Graph_load(dataset='citeseer') G = max(nx.connected_component_subgraphs(G), key=len) G = nx.convert_node_labels_to_integers(G) graphs = [] for i in range(G.number_of_nodes()): G_ego = nx.ego_graph(G, i, radius=1) if (G_ego.number_of_nodes() >= 4) and (G_ego.number_of_nodes() <= 20): graphs.append(G_ego) shuffle(graphs) graphs = graphs[0:200] args.max_prev_node = 15 return graphs
def test_graph(graph): """ Tests that the sampling method obtains correct counts for the path graph, wheel graph, and ladder graph (see networkx documentation for graph details). Large scale test that gives a basic sanity check of the whole sampling class. """ if graph == "path": path_graph = nx.path_graph(5) lift_unordered = lt.Lift(path_graph, 3, lift_type="unordered") graphlet_counts = lift_unordered.get_graphlet_count( num_steps=NUM_STEPS) assert graphlet_counts["wedge"] == 3 assert graphlet_counts["triangle"] == 0 lift_unordered = lt.Lift(path_graph, 2, lift_type="unordered") graphlet_counts = lift_unordered.get_graphlet_count( num_steps=NUM_STEPS) assert graphlet_counts["2-path"] == 4 print("Path graph passed.") elif graph == "wheel": wheel_graph = nx.wheel_graph(6) # this is a 6-cycle with a star center node lift_unordered = lt.Lift(wheel_graph, 3, lift_type="unordered") graphlet_counts = lift_unordered.get_graphlet_count( num_steps=NUM_STEPS) assert graphlet_counts["wedge"] == 10 assert graphlet_counts["triangle"] == 5 lift_unordered = lt.Lift(wheel_graph, 2, lift_type="unordered") graphlet_counts = lift_unordered.get_graphlet_count( num_steps=NUM_STEPS) assert graphlet_counts["2-path"] == 10 print("Wheel graph passed.") elif graph == "ladder": ladder_graph = nx.ladder_graph(4) # this is two 6-paths joined one to one lift_unordered = lt.Lift(ladder_graph, 3, lift_type="unordered") graphlet_counts = lift_unordered.get_graphlet_count( num_steps=NUM_STEPS) assert graphlet_counts["wedge"] == 16 assert graphlet_counts["triangle"] == 0 lift_unordered = lt.Lift(ladder_graph, 2, lift_type="unordered") graphlet_counts = lift_unordered.get_graphlet_count( num_steps=NUM_STEPS) assert graphlet_counts["2-path"] == 10 print("Ladder graph passed.") elif graph == "bio-celegansneural": graphlet_counts = run_test("bio-celegansneural", 3) actual_triangle_count = 12.6 * 10**3 / 3 assert ((graphlet_counts["triangle"] - actual_triangle_count) / actual_triangle_count < THRESHOLD) print(graph + " passed.") print(graphlet_counts, "\n") elif graph == "ia-email-univ": graphlet_counts = run_test("ia-email-univ", 3) actual_triangle_count = 16000 / 3 assert ((graphlet_counts["triangle"] - actual_triangle_count) / actual_triangle_count < THRESHOLD) print(graph + " passed.") print(graphlet_counts, "\n") elif graph == "misc-fullb": graphlet_counts = run_test("misc-fullb", 3) actual_triangle_count = 180.6 * 10**6 / 3 assert ((graphlet_counts["triangle"] - actual_triangle_count) / actual_triangle_count < THRESHOLD) print(graph + " passed.") print(graphlet_counts, "\n") elif graph == "misc-polblogs": graphlet_counts = run_test("misc-polblogs", 3) actual_triangle_count = 459.4 * 10**3 / 3 assert ((graphlet_counts["triangle"] - actual_triangle_count) / actual_triangle_count < THRESHOLD) print(graph + " passed.") print(graphlet_counts, "\n") else: print("Graph unknown.")
def generate_ladder_graphs(min_size: int = 100, max_size: int = 201): return [nx.ladder_graph(i) for i in range(min_size, max_size)]
def generate_ladder(n): graph_nx = nx.ladder_graph(n) return from_nx_to_torch(graph_nx)
n = 6 hypercube_n = 4 m = 6 r = 2 h = 3 dim = [2, 3] # left out dorogovtsev_goltsev_mendes_graph and null_graph graphs = [ ("balanced_tree", nx.balanced_tree(r, h)), ("barbell_graph", nx.barbell_graph(n, m)), ("complete_graph", nx.complete_graph(n)), ("complete_bipartite_graph", nx.complete_bipartite_graph(n, m)), ("circular_ladder_graph", nx.circular_ladder_graph(n)), ("cycle_graph", nx.cycle_graph(n)), ("empty_graph", nx.empty_graph(n)), ("grid_2d_graph", nx.grid_2d_graph(m, n)), ("grid_graph", nx.grid_graph(dim)), ("hypercube_graph", nx.hypercube_graph(hypercube_n)), ("ladder_graph", nx.ladder_graph(n)), ("lollipop_graph", nx.lollipop_graph(m, n)), ("path_graph", nx.path_graph(n)), ("star_graph", nx.star_graph(n)), ("trivial_graph", nx.trivial_graph()), ("wheel_graph", nx.wheel_graph(n)), ] plot_multigraph(graphs, 4, 4, node_size=50) plt.savefig("graphs/classic.png")
def gen_laplacian(data_num=DATA_NUM, opt=27, cache=False): label = None if cache: print('Loading cached graph') graph = pk.load(open('tmp/g.pk', 'rb')) else: print('Generating graph opt {}'.format(opt)) if 1 == opt: graph = gen_rand_graph(data_num=data_num) if 2 == opt: top_num = random.randint(1, data_num) bottom_num = data_num - top_num graph = nx.bipartite.random_graph(top_num, bottom_num, 0.9) label = [d['bipartite'] for n, d in graph.nodes(data=True)] elif 3 == opt: graph = nx.balanced_tree(4, 5) elif 4 == opt: graph = nx.complete_graph(data_num) elif 5 == opt: no1 = random.randint(1, data_num) no2 = random.randint(1, int(data_num / no1)) no3 = data_num / no1 / no2 graph = nx.complete_multipartite_graph(no1, no2, no3) elif 6 == opt: graph = nx.circular_ladder_graph(data_num) elif 7 == opt: graph = nx.cycle_graph(data_num) elif 8 == opt: graph = nx.dorogovtsev_goltsev_mendes_graph(5) elif 9 == opt: top_num = int(random.random() * data_num) bottom_num = data_num / top_num graph = nx.grid_2d_graph(top_num, bottom_num) elif 10 == opt: no1 = random.randint(1, data_num) no2 = random.randint(1, int(data_num / no1)) no3 = data_num / no1 / no2 graph = nx.grid_graph([no1, no2, no3]) elif 11 == opt: graph = nx.hypercube_graph(10) elif 12 == opt: graph = nx.ladder_graph(data_num) elif 13 == opt: top_num = int(random.random() * data_num) bottom_num = data_num - top_num graph = nx.lollipop_graph(top_num, bottom_num) elif 14 == opt: graph = nx.path_graph(data_num) elif 15 == opt: graph = nx.star_graph(data_num) elif 16 == opt: graph = nx.wheel_graph(data_num) elif 17 == opt: graph = nx.margulis_gabber_galil_graph(35) elif 18 == opt: graph = nx.chordal_cycle_graph(data_num) elif 19 == opt: graph = nx.fast_gnp_random_graph(data_num, random.random()) elif 20 == opt: # jump eigen value graph = nx.gnp_random_graph(data_num, random.random()) elif 21 == opt: # disconnected graph graph = nx.dense_gnm_random_graph(data_num, data_num / 2) elif 22 == opt: # disconnected graph graph = nx.gnm_random_graph(data_num, data_num / 2) elif 23 == opt: graph = nx.erdos_renyi_graph(data_num, data_num / 2) elif 24 == opt: graph = nx.binomial_graph(data_num, data_num / 2) elif 25 == opt: graph = nx.newman_watts_strogatz_graph(data_num, 5, random.random()) elif 26 == opt: graph = nx.watts_strogatz_graph(data_num, 5, random.random()) elif 26 == opt: # smooth eigen graph = nx.connected_watts_strogatz_graph(data_num, 5, random.random()) elif 27 == opt: # smooth eigen graph = nx.random_regular_graph(5, data_num) elif 28 == opt: # smooth eigen graph = nx.barabasi_albert_graph(data_num, 5) elif 29 == opt: # smooth eigen graph = nx.powerlaw_cluster_graph(data_num, 5, random.random()) elif 30 == opt: # smooth eigen graph = nx.duplication_divergence_graph(data_num, random.random()) elif 31 == opt: p = random.random() q = random.random() graph = nx.random_lobster(data_num, p, q) elif 32 == opt: p = random.random() q = random.random() k = random.random() graph = nx.random_shell_graph([(data_num / 3, 50, p), (data_num / 3, 40, q), (data_num / 3, 30, k)]) elif 33 == opt: # smooth eigen top_num = int(random.random() * data_num) bottom_num = data_num - top_num graph = nx.k_random_intersection_graph(top_num, bottom_num, 3) elif 34 == opt: graph = nx.random_geometric_graph(data_num, .1) elif 35 == opt: graph = nx.waxman_graph(data_num) elif 36 == opt: graph = nx.geographical_threshold_graph(data_num, .5) elif 37 == opt: top_num = int(random.random() * data_num) bottom_num = data_num - top_num graph = nx.uniform_random_intersection_graph( top_num, bottom_num, .5) elif 39 == opt: graph = nx.navigable_small_world_graph(data_num) elif 40 == opt: graph = nx.random_powerlaw_tree(data_num, tries=200) elif 41 == opt: graph = nx.karate_club_graph() elif 42 == opt: graph = nx.davis_southern_women_graph() elif 43 == opt: graph = nx.florentine_families_graph() elif 44 == opt: graph = nx.complete_multipartite_graph(data_num, data_num, data_num) # OPT 1 # norm_lap = nx.normalized_laplacian_matrix(graph).toarray() # OPT 2: renormalized # pk.dump(graph, open('tmp/g.pk', 'wb')) # plot_graph(graph, label) # note difference: normalized laplacian and normalzation by eigenvalue norm_lap, eigval, eigvec = normalize_lap(graph) return graph, norm_lap, eigval, eigvec
if __name__ == "__main__": argparser = ArgumentParser() argparser.add_argument("--method", default="laplacian") argparser.add_argument("--dataset", default="grid") argparser.add_argument("--cnt", default=3, type=int) args = argparser.parse_args() plt.figure(figsize=(12, 4)) for i in range(args.cnt): if args.dataset == "grid": A = nx.to_numpy_array(nx.grid_2d_graph(i + 2, i + 2)) if args.dataset == "ladder": A = nx.to_numpy_array(nx.ladder_graph(i + 4)) if args.method == "svd": U, S, V = np.linalg.svd(A) if args.method == "laplacian": S, V = np.linalg.eigh(np.diag(np.sum(A, axis=0)) - A) V = V.T[1:, :] if args.method == "lle": U, S, V = np.linalg.svd(np.eye(len(A)) - A) plt.subplot(3, args.cnt, i + 1) plt.imshow(V.T) plt.axis("off") plt.subplot(3, args.cnt, i + args.cnt + 1) nx.draw_spring(nx.from_numpy_array(A), node_size=20, node_color="black")
def create(args): ### load datasets graphs = [] # synthetic graphs if args.graph_type == 'ladder': graphs = [] for i in range(100, 201): graphs.append(nx.ladder_graph(i)) args.max_prev_node = 10 elif args.graph_type == 'ladder_small': graphs = [] for i in range(2, 11): graphs.append(nx.ladder_graph(i)) args.max_prev_node = 10 elif args.graph_type == 'tree': graphs = [] for i in range(2, 5): for j in range(3, 5): graphs.append(nx.balanced_tree(i, j)) args.max_prev_node = 256 elif args.graph_type == 'caveman': # graphs = [] # for i in range(5,10): # for j in range(5,25): # for k in range(5): # graphs.append(nx.relaxed_caveman_graph(i, j, p=0.1)) graphs = [] for i in range(2, 3): for j in range(30, 81): for k in range(10): graphs.append(caveman_special(i, j, p_edge=0.3)) args.max_prev_node = 100 elif args.graph_type == 'caveman_small': # graphs = [] # for i in range(2,5): # for j in range(2,6): # for k in range(10): # graphs.append(nx.relaxed_caveman_graph(i, j, p=0.1)) graphs = [] for i in range(2, 3): for j in range(6, 11): for k in range(20): graphs.append(caveman_special(i, j, p_edge=0.8)) # default 0.8 args.max_prev_node = 20 elif args.graph_type == 'caveman_small_single': # graphs = [] # for i in range(2,5): # for j in range(2,6): # for k in range(10): # graphs.append(nx.relaxed_caveman_graph(i, j, p=0.1)) graphs = [] for i in range(2, 3): for j in range(8, 9): for k in range(100): graphs.append(caveman_special(i, j, p_edge=0.5)) args.max_prev_node = 20 elif args.graph_type.startswith('community'): num_communities = int(args.graph_type[-1]) print('Creating dataset with ', num_communities, ' communities') c_sizes = np.random.choice([12, 13, 14, 15, 16, 17], num_communities) #c_sizes = [15] * num_communities for k in range(3000): graphs.append(n_community(c_sizes, p_inter=0.01)) args.max_prev_node = 80 elif args.graph_type == 'grid': graphs = [] for i in range(10, 20): for j in range(10, 20): graphs.append(nx.grid_2d_graph(i, j)) args.max_prev_node = 40 elif args.graph_type == 'grid_small': graphs = [] for i in range(2, 5): for j in range(2, 6): graphs.append(nx.grid_2d_graph(i, j)) args.max_prev_node = 15 elif args.graph_type == 'barabasi': graphs = [] for i in range(100, 200): for j in range(4, 5): for k in range(5): graphs.append(nx.barabasi_albert_graph(i, j)) args.max_prev_node = 130 elif args.graph_type == 'barabasi_small': graphs = [] for i in range(4, 21): for j in range(3, 4): for k in range(10): graphs.append(nx.barabasi_albert_graph(i, j)) args.max_prev_node = 20 elif args.graph_type == 'grid_big': graphs = [] for i in range(36, 46): for j in range(36, 46): graphs.append(nx.grid_2d_graph(i, j)) args.max_prev_node = 90 elif 'barabasi_noise' in args.graph_type: graphs = [] for i in range(100, 101): for j in range(4, 5): for k in range(500): graphs.append(nx.barabasi_albert_graph(i, j)) graphs = perturb_new(graphs, p=args.noise / 10.0) args.max_prev_node = 99 # real graphs elif args.graph_type == 'enzymes': graphs = Graph_load_batch(min_num_nodes=10, name='ENZYMES') args.max_prev_node = 25 elif args.graph_type == 'enzymes_small': graphs_raw = Graph_load_batch(min_num_nodes=10, name='ENZYMES') graphs = [] for G in graphs_raw: if G.number_of_nodes() <= 20: graphs.append(G) args.max_prev_node = 15 elif args.graph_type == 'protein': graphs = Graph_load_batch(min_num_nodes=20, name='PROTEINS_full') args.max_prev_node = 80 elif args.graph_type == 'DD': graphs = Graph_load_batch(min_num_nodes=100, max_num_nodes=500, name='DD', node_attributes=False, graph_labels=True) args.max_prev_node = 230 elif args.graph_type == 'citeseer': _, _, G = Graph_load(dataset='citeseer') G = max(nx.connected_component_subgraphs(G), key=len) G = nx.convert_node_labels_to_integers(G) graphs = [] for i in range(G.number_of_nodes()): G_ego = nx.ego_graph(G, i, radius=3) if G_ego.number_of_nodes() >= 50 and (G_ego.number_of_nodes() <= 400): graphs.append(G_ego) args.max_prev_node = 250 elif args.graph_type == 'citeseer_small': _, _, G = Graph_load(dataset='citeseer') G = max(nx.connected_component_subgraphs(G), key=len) G = nx.convert_node_labels_to_integers(G) graphs = [] for i in range(G.number_of_nodes()): G_ego = nx.ego_graph(G, i, radius=1) if (G_ego.number_of_nodes() >= 4) and (G_ego.number_of_nodes() <= 20): graphs.append(G_ego) shuffle(graphs) graphs = graphs[0:200] args.max_prev_node = 15 elif args.graph_type == 'AST' or args.graph_type == '200Graphs': graphs = ast_graph_load_batch(min_num_nodes=10, name=args.graph_type) # update edge_feature_output_dim if not args.max_node_feature_num: # print(type(graphs[1].nodes._nodes), graphs[1].nodes._nodes.keys()) args.max_node_feature_num = len( list(graphs[1].nodes._nodes._atlas[1].keys()) ) # now equals to 28 args.max_prev_node = 120 # TODO: args.max_edge_feature_num update if not args.edge_feature_output_dim: args.edge_feature_output_dim = args.max_edge_feature_num + 2 #int(args.max_prev_node * args.max_edge_feature_num) # 2 indicates two directions of edges if not args.node_feature_input_dim: args.node_feature_input_dim = args.max_node_feature_num + args.max_prev_node + args.edge_feature_output_dim # args.node_feature_input_dim = args.max_prev_node return graphs
if not os.path.exists(args.output): os.makedirs(args.output) with open(args.output + '/output.csv', 'w') as output: helper(output, nx.balanced_tree(2, 5), "balanced_tree") # branching factor, height helper(output, nx.barbell_graph(50, 50), "barbell_graph") helper(output, nx.complete_graph(50), "complete_graph") helper(output, nx.complete_bipartite_graph(50, 50), "complete_bipartite_graph") helper(output, nx.circular_ladder_graph(50), "circular_ladder_graph") helper(output, nx.cycle_graph(50), "cycle_graph") helper(output, nx.dorogovtsev_goltsev_mendes_graph(5), "dorogovtsev_goltsev_mendes_graph") helper(output, nx.empty_graph(50), "empty_graph") helper(output, nx.grid_2d_graph(5, 20), "grid_2d_graph") helper(output, nx.grid_graph([2, 3]), "grid_graph") helper(output, nx.hypercube_graph(3), "hypercube_graph") helper(output, nx.ladder_graph(50), "ladder_graph") helper(output, nx.lollipop_graph(5, 20), "lollipop_graph") helper(output, nx.path_graph(50), "path_graph") helper(output, nx.star_graph(50), "star_graph") helper(output, nx.trivial_graph(), "trivial_graph") helper(output, nx.wheel_graph(50), "wheel_graph") helper(output, nx.random_regular_graph(1, 50, 678995), "random_regular_graph_1") helper(output, nx.random_regular_graph(3, 50, 683559), "random_regular_graph_3") helper(output, nx.random_regular_graph(5, 50, 515871), "random_regular_graph_5") helper(output, nx.random_regular_graph(8, 50, 243579), "random_regular_graph_8") helper(output, nx.random_regular_graph(13, 50, 568324), "random_regular_graph_13") helper(output, nx.diamond_graph(), "diamond_graph")
def create(args): ### load datasets graphs = [] # synthetic graphs if args.graph_type == 'ladder': graphs = [] for i in range(100, 201): graphs.append(nx.ladder_graph(i)) args.max_prev_node = 10 elif args.graph_type == 'ladder_small': graphs = [] for i in range(2, 11): graphs.append(nx.ladder_graph(i)) args.max_prev_node = 10 elif args.graph_type == 'tree': graphs = [] for i in range(2, 5): for j in range(3, 5): graphs.append(nx.balanced_tree(i, j)) args.max_prev_node = 256 elif args.graph_type == 'caveman': # graphs = [] # for i in range(5,10): # for j in range(5,25): # for k in range(5): # graphs.append(nx.relaxed_caveman_graph(i, j, p=0.1)) graphs = [] for i in range(2, 3): for j in range(30, 81): for k in range(10): graphs.append(caveman_special(i, j, p_edge=0.3)) args.max_prev_node = 100 elif args.graph_type == 'caveman_small': # graphs = [] # for i in range(2,5): # for j in range(2,6): # for k in range(10): # graphs.append(nx.relaxed_caveman_graph(i, j, p=0.1)) graphs = [] for i in range(2, 3): for j in range(6, 11): for k in range(20): graphs.append(caveman_special(i, j, p_edge=0.8)) # default 0.8 args.max_prev_node = 20 elif args.graph_type == 'caveman_small_single': # graphs = [] # for i in range(2,5): # for j in range(2,6): # for k in range(10): # graphs.append(nx.relaxed_caveman_graph(i, j, p=0.1)) graphs = [] for i in range(2, 3): for j in range(8, 9): for k in range(100): graphs.append(caveman_special(i, j, p_edge=0.5)) args.max_prev_node = 20 elif args.graph_type.startswith('community'): num_communities = int(args.graph_type[-1]) print('Creating dataset with ', num_communities, ' communities') c_sizes = np.random.choice([12, 13, 14, 15, 16, 17], num_communities) #c_sizes = [15] * num_communities for k in range(3000): graphs.append(n_community(c_sizes, p_inter=0.01)) args.max_prev_node = 80 elif args.graph_type == 'grid': graphs = [] for i in range(10, 20): for j in range(10, 20): graphs.append(nx.grid_2d_graph(i, j)) args.max_prev_node = 40 elif args.graph_type == 'grid_small': graphs = [] for i in range(2, 5): for j in range(2, 6): graphs.append(nx.grid_2d_graph(i, j)) args.max_prev_node = 15 elif args.graph_type == 'barabasi': graphs = [] for i in range(100, 200): for j in range(4, 5): for k in range(5): graphs.append(nx.barabasi_albert_graph(i, j)) args.max_prev_node = 130 elif args.graph_type == 'barabasi_small': graphs = [] for i in range(4, 21): for j in range(3, 4): for k in range(10): graphs.append(nx.barabasi_albert_graph(i, j)) args.max_prev_node = 20 elif args.graph_type == 'grid_big': graphs = [] for i in range(36, 46): for j in range(36, 46): graphs.append(nx.grid_2d_graph(i, j)) args.max_prev_node = 90 elif 'barabasi_noise' in args.graph_type: graphs = [] for i in range(100, 101): for j in range(4, 5): for k in range(500): graphs.append(nx.barabasi_albert_graph(i, j)) graphs = perturb_new(graphs, p=args.noise / 10.0) args.max_prev_node = 99 # real graphs elif args.graph_type == 'enzymes': graphs = Graph_load_batch(min_num_nodes=10, name='ENZYMES') args.max_prev_node = 25 elif args.graph_type == 'enzymes_small': graphs_raw = Graph_load_batch(min_num_nodes=10, name='ENZYMES') graphs = [] for G in graphs_raw: if G.number_of_nodes() <= 20: graphs.append(G) args.max_prev_node = 15 elif args.graph_type == 'protein': graphs = Graph_load_batch(min_num_nodes=20, name='PROTEINS_full') args.max_prev_node = 80 elif args.graph_type == 'DD': graphs = Graph_load_batch(min_num_nodes=100, max_num_nodes=500, name='DD', node_attributes=False, graph_labels=True) args.max_prev_node = 230 elif args.graph_type == 'citeseer': _, _, G = Graph_load(dataset='citeseer') G = max(nx.connected_component_subgraphs(G), key=len) G = nx.convert_node_labels_to_integers(G) graphs = [] for i in range(G.number_of_nodes()): G_ego = nx.ego_graph(G, i, radius=3) if G_ego.number_of_nodes() >= 50 and (G_ego.number_of_nodes() <= 400): graphs.append(G_ego) args.max_prev_node = 250 elif args.graph_type == 'citeseer_small': _, _, G = Graph_load(dataset='citeseer') G = max(nx.connected_component_subgraphs(G), key=len) G = nx.convert_node_labels_to_integers(G) graphs = [] for i in range(G.number_of_nodes()): G_ego = nx.ego_graph(G, i, radius=1) if (G_ego.number_of_nodes() >= 4) and (G_ego.number_of_nodes() <= 20): graphs.append(G_ego) shuffle(graphs) graphs = graphs[0:200] args.max_prev_node = 15 elif args.graph_type == 'RNA1': args.max_prev_node = 100 graphs = Untitled.get_all_graphs(fasta='RF00162.fa', maxgr=0) #graphs = pickle.load(open("RNA1.pkl","rb")) elif args.graph_type == 'RNA2': args.max_prev_node = 100 graphs = Untitled.get_all_graphs(fasta='RF01725.fa', maxgr=0) #graphs = pickle.load(open("RNA2.pkl","rb")) #print (graphs) return graphs
def create(args): ### load datasets graphs=[] # synthetic graphs if args.graph_type=='ladder': graphs = [] for i in range(100, 201): graphs.append(nx.ladder_graph(i)) args.max_prev_node = 10 elif args.graph_type=='ladder_small': graphs = [] for i in range(2, 11): graphs.append(nx.ladder_graph(i)) args.max_prev_node = 10 elif args.graph_type=='tree': graphs = [] for i in range(2,5): for j in range(3,5): graphs.append(nx.balanced_tree(i,j)) args.max_prev_node = 256 elif args.graph_type=='caveman': # graphs = [] # for i in range(5,10): # for j in range(5,25): # for k in range(5): # graphs.append(nx.relaxed_caveman_graph(i, j, p=0.1)) graphs = [] for i in range(2, 3): for j in range(30, 81): for k in range(10): graphs.append(caveman_special(i,j, p_edge=0.3)) args.max_prev_node = 100 elif args.graph_type=='caveman_small': # graphs = [] # for i in range(2,5): # for j in range(2,6): # for k in range(10): # graphs.append(nx.relaxed_caveman_graph(i, j, p=0.1)) graphs = [] for i in range(2, 3): for j in range(6, 11): for k in range(20): graphs.append(caveman_special(i, j, p_edge=0.8)) # default 0.8 args.max_prev_node = 20 elif args.graph_type=='caveman_small_single': # graphs = [] # for i in range(2,5): # for j in range(2,6): # for k in range(10): # graphs.append(nx.relaxed_caveman_graph(i, j, p=0.1)) graphs = [] for i in range(2, 3): for j in range(8, 9): for k in range(100): graphs.append(caveman_special(i, j, p_edge=0.5)) args.max_prev_node = 20 elif args.graph_type.startswith('community'): num_communities = int(args.graph_type[-1]) print('Creating dataset with ', num_communities, ' communities') c_sizes = np.random.choice([12, 13, 14, 15, 16, 17], num_communities) #c_sizes = [15] * num_communities for k in range(3000): graphs.append(n_community(c_sizes, p_inter=0.01)) args.max_prev_node = 80 elif args.graph_type=='grid': graphs = [] for i in range(10,20): for j in range(10,20): graphs.append(nx.grid_2d_graph(i,j)) args.max_prev_node = 40 elif args.graph_type=='grid_small': graphs = [] for i in range(2,5): for j in range(2,6): graphs.append(nx.grid_2d_graph(i,j)) args.max_prev_node = 15 elif args.graph_type=='barabasi': graphs = [] for i in range(100,200): for j in range(4,5): for k in range(5): graphs.append(nx.barabasi_albert_graph(i,j)) args.max_prev_node = 130 elif args.graph_type=='barabasi_small': graphs = [] for i in range(4,21): for j in range(3,4): for k in range(10): graphs.append(nx.barabasi_albert_graph(i,j)) args.max_prev_node = 20 elif args.graph_type=='grid_big': graphs = [] for i in range(36, 46): for j in range(36, 46): graphs.append(nx.grid_2d_graph(i, j)) args.max_prev_node = 90 elif 'barabasi_noise' in args.graph_type: graphs = [] for i in range(100,101): for j in range(4,5): for k in range(500): graphs.append(nx.barabasi_albert_graph(i,j)) graphs = perturb_new(graphs,p=args.noise/10.0) args.max_prev_node = 99 # real graphs elif args.graph_type == 'enzymes': graphs= Graph_load_batch(min_num_nodes=10, name='ENZYMES') args.max_prev_node = 25 elif args.graph_type == 'enzymes_small': graphs_raw = Graph_load_batch(min_num_nodes=10, name='ENZYMES') graphs = [] for G in graphs_raw: if G.number_of_nodes()<=20: graphs.append(G) args.max_prev_node = 15 elif args.graph_type == 'protein': graphs = Graph_load_batch(min_num_nodes=20, name='PROTEINS_full') args.max_prev_node = 80 elif args.graph_type == 'DD': graphs = Graph_load_batch(min_num_nodes=100, max_num_nodes=500, name='DD',node_attributes=False,graph_labels=True) args.max_prev_node = 230 elif args.graph_type == 'citeseer': _, _, G = Graph_load(dataset='citeseer') G = max(nx.connected_component_subgraphs(G), key=len) G = nx.convert_node_labels_to_integers(G) graphs = [] for i in range(G.number_of_nodes()): G_ego = nx.ego_graph(G, i, radius=3) if G_ego.number_of_nodes() >= 50 and (G_ego.number_of_nodes() <= 400): graphs.append(G_ego) args.max_prev_node = 250 elif args.graph_type == 'citeseer_small': _, _, G = Graph_load(dataset='citeseer') G = max(nx.connected_component_subgraphs(G), key=len) G = nx.convert_node_labels_to_integers(G) graphs = [] for i in range(G.number_of_nodes()): G_ego = nx.ego_graph(G, i, radius=1) if (G_ego.number_of_nodes() >= 4) and (G_ego.number_of_nodes() <= 20): graphs.append(G_ego) shuffle(graphs) graphs = graphs[0:200] args.max_prev_node = 15 elif args.graph_type == 'generated': graphs = [] file_list = glob.glob('./generated_graphs/*.pkl') file_list = [s for s in file_list if args.generated_name in s and args.generated_size in s] print('File_list:\n{}'.format(file_list)) for file in file_list: A = pkl.load(open(file, 'rb'), encoding='latin-1') for graph in A['data']: G = nx.from_numpy_matrix(graph) graphs.append(G) args.max_prev_node = 63 return graphs
def test_result_ladder_graph_200(self): assert (calc_and_compare(NX.ladder_graph(200)))
import networkx as nx G = nx.Graph() G.add_node(1) G.add_node(2) G.add_node(3) G.add_edge(1, 2) G.add_edge(1, 3) G.nodes() #to display nodes G.edges() #to display edges G.order() # tells no of nodes in the Graph G.size() # tells no of edges in the graph Z = nx.complete_graph(10) # draws a complete graph H = nx.gnp_random_graph( 20, 0.5 ) #draws random graph of 20 nodes with edges being contected with prob 0.5 C = nx.cycle_graph(5) L = nx.ladder_graph(5) P = nx.path_graph(6) S = nx.star_graph(5) #5 outer nodes and 1 hub node W = nx.wheel_graph(5) B = nx.barbell_graph(4, 2) # 4 is no of community; 2 no of ibw nodes O = nx.complete_graph(4) import matplotlib.pyplot as plt # nx.draw(G) #simply nodes nx.draw(S, with_labels=1) plt.show()