def node2vec_embedding(graph): p = 1.0 q = 1.0 dimensions = 128 num_walks = 10 walk_length = 80 window_size = 10 num_iter = 1 workers = multiprocessing.cpu_count() graph = StellarGraph(graph) rw = BiasedRandomWalk(graph) walks = rw.run(graph.nodes(), n=num_walks, length=walk_length, p=p, q=q) print(f"Number of random walks: {len(walks)}") model = Word2Vec(walks, size=dimensions, window=window_size, min_count=0, sg=1, workers=workers, iter=num_iter) features = pd.DataFrame(data=model.wv.vectors, index=list(graph.nodes())) features.index = features.index.map(str) return features
def prepare_data_for_stellargraph(self): def load_raw_input(): adj = np.load(os.path.join(self.data_path, 'adj.pkl'), allow_pickle=True) features = np.load(os.path.join(self.data_path, 'features.pkl'), allow_pickle=True) labels = np.load(os.path.join(self.data_path, 'train.pkl'), allow_pickle=True) return adj, features, labels print("Reading raw inputs...") adj, features, labels = load_raw_input() print("creating nodes...") adj_list = [[i, j, adj[i, j]] for i, j in zip(*adj.nonzero())] tmp_df = pd.DataFrame(adj_list) tmp_df.columns = ["source", "target", "weight"] print("creating edges...") feature_df = pd.DataFrame(features) feature_df.columns = [f"w{i}" for i in range(feature_df.shape[1])] print("creating labels...") label_series = pd.DataFrame({"label": labels})["label"] my_graph = StellarGraph({"paper": feature_df}, {"cites": tmp_df}) print(my_graph.info()) return my_graph, label_series
def load_from_file(filePrefix): nodes_filename = filePrefix + "_nodes.txt" edges_filename = filePrefix + "_edges.txt" node_features = None edge_features = None #https://stellargraph.readthedocs.io/en/stable/demos/basics/loading-numpy.html with open(nodes_filename) as f: num_nodes, num_node_features = map(int, f.readline().split('\t')[:-1]) if num_node_features > 0: node_features = np.zeros((num_node_features, num_nodes)) for i, line in enumerate(f.readlines()): features = np.array(list(map(float, line.split('\t')[1:-1]))) for fIndex in range(num_node_features): node_features[fIndex][i] = features[fIndex] #node_features[i] = features # read edge features with open(edges_filename) as f: num_edges, num_edge_features = map(int, f.readline().split('\t')[:-1]) senders = np.zeros(num_edges, dtype=int) receivers = np.zeros(num_edges, dtype=int) if num_edge_features > 0: edge_features = np.zeros((num_edge_features, num_edges)) for i, line in enumerate(f.readlines()): elements = line.split('\t') senders[i] = int(elements[0]) receivers[i] = int(elements[1]) if edge_features is not None: features = np.array(list(map(float, elements[2:-1]))) for fIndex in range(num_edge_features): edge_features[fIndex][i] = features[fIndex] #edge_features[i] = np.array(list(map(float, elements[2:-1]))) square_numeric_edges = pd.DataFrame({ "source": senders, "target": receivers }) square_node_data = pd.DataFrame({"x": node_features[0].tolist()}) #square_node_data = pd.DataFrame( { "x": node_features[0].tolist(), "y": node_features[1].tolist(), "z" : node_features[2].tolist() } ) #feature_array = np.array([[1.0, -0.2], [2.0, 0.3], [3.0, 0.0], [4.0, -0.5]], dtype=np.float32) #print("node_features") #print(node_features) #print("square_numeric_edges") #print(square_numeric_edges) square_numeric = StellarGraph(square_node_data, edges=square_numeric_edges) print("GRAPH INFO") print("....................................") print(square_numeric.info()) print("....................................") return square_numeric
def example_graph_1(feature_size=None): G = nx.Graph() elist = [(1, 2), (2, 3), (1, 4), (3, 2), (5, 6), (1, 5)] G.add_nodes_from([1, 2, 3, 4, 5, 6], label="default") G.add_edges_from(elist, label="default") # Add example features if feature_size is not None: for v in G.nodes(): G.nodes[v]["feature"] = np.ones(feature_size) return StellarGraph(G, node_features="feature") else: return StellarGraph(G)
def arange_graph(request): shape = (3, 7, 11) if request.param == "multivariate" else (3, 7) total_elems = np.product(shape) nodes = IndexedArray(np.arange(total_elems).reshape(shape) / total_elems, index=["a", "b", "c"]) edges = pd.DataFrame({"source": ["a", "b"], "target": ["b", "c"]}) return StellarGraph(nodes, edges)
def graphCreationForSingleStudent(transitionRow, activityCodeList, mode='networkx'): #transitionRow as series transitionList = generateTransition(activityCodeList) checkActivityList = [] G = nx.Graph() for i in transitionList: if i[1] in transitionRow.index: if transitionRow[i[1]] > 0: if i[0][0] not in checkActivityList: G.add_node(i[0][0], weight=transitionRow[i[2][0]], name=i[2][0]) checkActivityList.append(i[0][0]) if i[0][1] not in checkActivityList: G.add_node(i[0][1], weight=transitionRow[i[2][1]], name=i[2][1]) checkActivityList.append(i[0][1]) G.add_edge(i[0][0], i[0][1], weight=transitionRow[i[1]]) if mode == 'networkx': return G else: return StellarGraph.from_networkx(G)
def test_APPNP_linkmodel_apply_dense(): G, features = create_graph_features() adj = nx.to_numpy_array(G)[None, :, :] n_nodes = features.shape[0] nodes = G.nodes() node_features = pd.DataFrame.from_dict( {n: f for n, f in zip(nodes, features)}, orient="index") G = StellarGraph(G, node_features=node_features) generator = FullBatchLinkGenerator(G, sparse=False, method="none") appnpnModel = APPNP([3], generator, activations=["relu"], dropout=0.5) x_in, x_out = appnpnModel.build() model = keras.Model(inputs=x_in, outputs=x_out) # Check fit method out_indices = np.array([[[0, 1], [1, 2]]], dtype="int32") preds_1 = model.predict([features[None, :, :], out_indices, adj]) assert preds_1.shape == (1, 2, 2, 3) # Check fit_generator method preds_2 = model.predict_generator(generator.flow([("a", "b"), ("b", "c")])) assert preds_2.shape == (1, 2, 2, 3) assert preds_1 == pytest.approx(preds_2)
def test_PPNP_edge_cases(): G, features = create_graph_features() adj = nx.to_scipy_sparse_matrix(G) features, adj = PPNP_Aadj_feats_op(features, adj) nodes = G.nodes() node_features = pd.DataFrame.from_dict( {n: f for n, f in zip(nodes, features)}, orient="index" ) G = StellarGraph(G, node_features=node_features) ppnp_sparse_failed = False try: generator = FullBatchNodeGenerator(G, sparse=True, method="ppnp") except ValueError as e: ppnp_sparse_failed = True assert ppnp_sparse_failed generator = FullBatchNodeGenerator(G, sparse=False, method="ppnp") try: ppnpModel = PPNP([2, 2], generator=generator, activations=["relu"], dropout=0.5) except ValueError as e: error = e assert str(error) == "The number of layers should equal the number of activations" try: ppnpModel = PPNP([2], generator=[0, 1], activations=["relu"], dropout=0.5) except TypeError as e: error = e assert str(error) == "Generator should be a instance of FullBatchNodeGenerator"
def example_graph_1_saliency_maps(feature_size=None): # saliency gcn, saliency gat graph = nx.Graph() elist = [(0, 1), (0, 2), (2, 3), (3, 4), (0, 0), (1, 1), (2, 2), (3, 3), (4, 4)] graph.add_nodes_from([0, 1, 2, 3, 4], label="default") graph.add_edges_from(elist, label="default") # Add example features if feature_size is not None: for v in graph.nodes(): graph.nodes[v]["feature"] = np.ones(feature_size) return StellarGraph(graph, node_features="feature") else: return StellarGraph(graph)
def test_PPNP_apply_dense(): G, features = create_graph_features() adj = nx.to_scipy_sparse_matrix(G) features, adj = PPNP_Aadj_feats_op(features, adj) adj = adj[None, :, :] nodes = G.nodes() node_features = pd.DataFrame.from_dict( {n: f for n, f in zip(nodes, features)}, orient="index" ) G = StellarGraph(G, node_features=node_features) generator = FullBatchNodeGenerator(G, sparse=False, method="ppnp") ppnpModel = PPNP([2], generator=generator, activations=["relu"], dropout=0.5) x_in, x_out = ppnpModel.build() model = keras.Model(inputs=x_in, outputs=x_out) # Check fit method out_indices = np.array([[0, 1]], dtype="int32") preds_1 = model.predict([features[None, :, :], out_indices, adj]) assert preds_1.shape == (1, 2, 2) # Check fit_generator method preds_2 = model.predict_generator(generator.flow(["a", "b"])) assert preds_2.shape == (1, 2, 2) assert preds_1 == pytest.approx(preds_2)
def weighted_hin(): a_ids = [0, 1, 2, 3] a = pd.DataFrame(index=a_ids) b_ids = [4, 5, 6] b = pd.DataFrame(index=b_ids) # no weights A-R->A r_ids = [7, 8] r = pd.DataFrame([(0, 1), (0, 2)], columns=["source", "target"], index=r_ids) # single weighted edge A-S->A s_ids = [9, 10] s = pd.DataFrame([(0, 3, 2)], columns=["source", "target", "weight"], index=s_ids) # 3 edges with same weight A-T->B t_ids = [11, 12, 13] t = pd.DataFrame( [(0, 4, 2), (0, 5, 2), (0, 6, 2)], columns=["source", "target", "weight"], index=t_ids, ) # weights [2, 3] A-U->A; weights [4, 5, 6] A-U->B u_ids = [14, 15, 16, 17, 18] u = pd.DataFrame( [(1, 2, 2), (1, 3, 3), (1, 4, 4), (1, 4, 5), (6, 1, 5)], columns=["source", "target", "weight"], index=u_ids, ) return StellarGraph(nodes={"A": a, "B": b}, edges={"R": r, "S": s, "T": t, "U": u})
def test_APPNP_apply_propagate_model_dense(): G, features = create_graph_features() adj = nx.to_scipy_sparse_matrix(G) features, adj = GCN_Aadj_feats_op(features, adj) adj = np.array(adj.todense()[None, :, :]) n_nodes = features.shape[0] nodes = G.nodes() node_features = pd.DataFrame.from_dict( {n: f for n, f in zip(nodes, features)}, orient="index") G = StellarGraph(G, node_features=node_features) generator = FullBatchNodeGenerator(G, sparse=False, method="gcn") appnpnModel = APPNP([2], generator=generator, activations=["relu"], dropout=0.5) fully_connected_model = keras.Sequential() fully_connected_model.add(Dense(2)) x_in, x_out = appnpnModel.propagate_model(fully_connected_model) model = keras.Model(inputs=x_in, outputs=x_out) # Check fit method out_indices = np.array([[0, 1]], dtype="int32") preds_1 = model.predict([features[None, :, :], out_indices, adj]) assert preds_1.shape == (1, 2, 2) # Check fit_generator method preds_2 = model.predict_generator(generator.flow(["a", "b"])) assert preds_2.shape == (1, 2, 2) assert preds_1 == pytest.approx(preds_2)
def create_graph_features(): # APPNP, ClusterGCN, GCN, PPNP, node_mappers, full_batch_generators features = np.array([[1, 1], [1, 0], [0, 1]]) nodes = pd.DataFrame(features, index=["a", "b", "c"]) edges = pd.DataFrame([("a", "b"), ("b", "c"), ("a", "c")], columns=["source", "target"]) return StellarGraph(nodes, edges), features
def learn_embeddings(self, embedding_dim=100, window_size=5, max_rw_len=50, walks_per_node=20, p=0.5, q=2.0): print('Running node2vec...') rw = BiasedRandomWalk(StellarGraph(self.graph)) walks = rw.run(nodes=list(self.graph), length=max_rw_len, n=walks_per_node, p=p, q=q) print(f'Number of random walks: {len(walks)}') print('Running word2vec...') model = Word2Vec(walks, size=embedding_dim, window=window_size, min_count=0, sg=1, workers=2, iter=1) model.init_sims(replace=True) return model.wv
def intra_and_inter(pep, hla, after_pca): source, target = Graph_Constructor.combinator(pep, hla) combine = list(itertools.product(source, target)) weight = itertools.repeat(2, len(source) * len(target)) edges_inter = pd.DataFrame({ 'source': [item[0] for item in combine], 'target': [item[1] for item in combine], 'weight': weight }) intra_pep = list(itertools.combinations(source, 2)) intra_hla = list(itertools.combinations(target, 2)) intra = intra_pep + intra_hla weight = itertools.repeat(1, len(intra)) edges_intra = pd.DataFrame({ 'source': [item[0] for item in intra], 'target': [item[1] for item in intra], 'weight': weight }) edges = pd.concat([edges_inter, edges_intra]) edges = edges.set_index(pd.Index(np.arange(edges.shape[0]))) feature_array = Graph_Constructor.numerical(pep, hla, after_pca) nodes = IndexedArray(feature_array, index=source + target) graph = StellarGraph(nodes, edges, node_type_default='corner', edge_type_default='line') return graph
def walks(self, walklen, n1): G = nx.Graph() G = nx.read_weighted_edgelist(self.dataset + "/krnmdata1/CQAG1.txt") rw = BiasedRandomWalk(StellarGraph(G)) weighted_walks = rw.run( nodes=G.nodes(), # root nodes length=walklen, # maximum length of a random walk n=n1, # number of random walks per root node p=0.5, # Defines (unormalised) probability, 1/p, of returning to source node q=2.0, # Defines (unormalised) probability, 1/q, for moving away from source node weighted=True, #for weighted random walks seed=42 # random seed fixed for reproducibility ) print("Number of random walks: {}".format(len(weighted_walks))) #print(weighted_walks[0:10]) #remove answer nodes walks = [] for i in range(len(weighted_walks)): walk = weighted_walks[i] w = [] for node in walk: if int(node) < self.qnum: w.append(node) elif int(node) > (self.qnum + self.anum): n = int(node) - self.anum w.append(str(n)) walks.append(w) print(walks[0:10]) return walks
def graph_embed(): combine = get_combine() li = ['bank', 'acquirer', 'coin', 'mcc', 'shop', 'nation', 'city'] d = { 'bank': 'b', 'mcc': 'm', 'acquirer': 'a', 'coin': 'c', 'shop': 's', 'nation': 'n', 'city': 'z' } have_df = False df_all = None for col_a in li: combine[col_a] = combine[col_a].astype(str) + [d[col_a]] for index, col_a in enumerate(li[1:]): print(f'{col_a} started..') walk_all = [] for day in np.linspace(1, 120, 120): print(day, end=',', flush=True) df = combine[combine['date'] == day] G = construct_graph('bank', col_a, df) rw = BiasedRandomWalk(StellarGraph(G)) walk = rw.run( nodes=list(G.nodes()), # root nodes length=80, # maximum length of a random walk n=1, # number of random walks per root node p=1, # Defines (unormalised) probability, 1/p, of returning to source node q=1, # Defines (unormalised) probability, 1/q, for moving away from source node ) walk_all.extend(walk) del df, G, rw, walk gc.collect() model = Word2Vec(walk_all, size=5, window=3, min_count=1, sg=0, workers=16, iter=10) temp_d = {} for w in list(model.wv.vocab): temp_d[w] = model[w] temp_df = pd.DataFrame( data=combine[col_a].map(temp_d).tolist(), columns=['embed_bank_' + col_a + str(x + 1) for x in range(5)]) if (have_df): df_all = pd.concat([df_all, temp_df], axis=1) else: df_all = temp_df have_df = True del temp_d, model gc.collect() return df_all
def example_graph_random(feature_size=4, n_edges=20, n_nodes=6, n_isolates=1): # core/utils, link mapper, node mapper graph 3 graph = nx.Graph() n_noniso = n_nodes - n_isolates edges = [(random.randint(0, n_noniso - 1), random.randint(0, n_noniso - 1)) for _ in range(n_edges)] graph.add_nodes_from(range(n_nodes)) graph.add_edges_from(edges, label="default") # Add example features if feature_size is not None: for v in graph.nodes(): graph.nodes[v]["feature"] = int(v) * np.ones(feature_size, dtype="int") return StellarGraph(graph, node_features="feature") else: return StellarGraph(graph)
def create_stellargraph(): # cluster gcn, cluster gcn node mapper Gnx, features = create_graph_features() nodes = Gnx.nodes() node_features = pd.DataFrame.from_dict( {n: f for n, f in zip(nodes, features)}, orient="index") graph = StellarGraph(Gnx, node_features=node_features) return graph
def load4graph(self): """ 将所有边和顶点信息装入图,并生成游走路径rw :return: """ g_nx = self.load_dataset_SMDB(self.location, self.graph_infos) print("Number of nodes {} and number of edges {} in graph.".format(g_nx.number_of_nodes(), g_nx.number_of_edges())) from stellargraph.data import UniformRandomMetaPathWalk rw = UniformRandomMetaPathWalk(StellarGraph(g_nx)) return g_nx, rw
def __init__(self, edges_path, lables_path): """ Hard-coded initialization """ fstar = 1 a = 0.125 # p, q left bound b = 4.125 # p, q right bound graph, labels = self.read_data(edges_path, lables_path) rw = BiasedRandomWalk(StellarGraph.from_networkx(graph)) super().__init__(fstar, a, b, graph, labels, rw)
def eda(graph): ''' eda for an apk graph --> filepath to a graph returns a dictionary in case ''' app_dir, app_filename = os.path.split(graph) #building output target = "/teams/DSC180A_FA20_A00/a04malware/personal-group03/eda_sab/features1/" out_csv = os.path.join(target, (app_filename + ".csv")) target1 = "/teams/DSC180A_FA20_A00/a04malware/personal-group03/eda/features/" others = os.path.join(target1, (app_filename + ".csv")) if os.path.exists(out_csv): print("csv exists already") return "csv exists already" if os.path.exists(others): print("csv others exists already") return "csv others exists already" try: networkx = nx.read_gml(graph) except: return graph + " might be broken!" stellar = StellarGraph.from_networkx(networkx, node_type_attr = "type") nodes = stellar.node_types node_types = {} for node in nodes: node_types[node] = len(stellar.nodes_of_type(node_type=node)) data = {} # get number of nodes and edges data["app"] = graph data["node_types_counts"] = len(stellar.node_types) data["node_types"] = node_types data["number_nodes"] = len(stellar.nodes()) data["number_edges"] = len(stellar.edges()) if "benign" in app_dir: label = 0 else: label = 1 data["label"] = label df = pd.DataFrame.from_dict([data]) return df.to_csv(out_csv)
def example_graph_2(feature_size=None, label="default") -> StellarGraph: # unsupervised sampler, link mapper elist = pd.DataFrame([(1, 2), (2, 3), (1, 4), (4, 2)], columns=["source", "target"]) nodes = [1, 2, 3, 4] if feature_size is not None: features = _repeated_features(nodes, feature_size) else: features = [] nodes = pd.DataFrame(features, index=nodes) return StellarGraph(nodes={label: nodes}, edges={label: elist})
def example_graph_1(feature_size=None): nlist = [1, 2, 3, 4, 5, 6] if feature_size is not None: features = np.ones((len(nlist), feature_size)) else: features = [] elist = [(1, 2), (2, 3), (1, 4), (3, 2), (5, 6), (1, 5)] return StellarGraph( pd.DataFrame(features, index=nlist), pd.DataFrame(elist, columns=["source", "target"]), )
def example_graph_1_saliency_maps(feature_size=None): # saliency gcn, saliency gat nlist = [0, 1, 2, 3, 4] if feature_size is None: nodes = pd.DataFrame(index=nlist) else: # Example features nodes = pd.DataFrame(np.ones((len(nlist), feature_size)), index=nlist) elist = [(0, 1), (0, 2), (2, 3), (3, 4), (0, 0), (1, 1), (2, 2), (3, 3), (4, 4)] edges = pd.DataFrame(elist, columns=["source", "target"]) return StellarGraph(nodes, edges)
def _metapath_randomwalk(graph): # Create the random walker rw = UniformRandomMetaPathWalk(StellarGraph(graph)) # specify the metapath schemas as a list of lists of node types. walks = rw.run(nodes=list(graph.nodes()), # root nodes length=WALK_DISTANCE, # maximum length of a random walk n=1, # number of random walks per root node metapaths=METAPATHS # the metapaths ) print("Number of random walks: {}".format(len(walks))) return walks
def preprocessing(self, g, train_node, file_emb_output="./emb/100_900_nede2vec.emb"): node_subjects = train_node['values'] node_subjects = node_subjects.astype(str) print(Counter(node_subjects)) #file_emb_output = "./emb/100_900_nede2vec.emb" model = KeyedVectors.load_word2vec_format(file_emb_output) node_ids = model.wv.index2word node_embeddings = ( model.wv.vectors ) # num print("Embedding load success.") reinex_node_embedding = pd.DataFrame(node_embeddings, index=map(int, node_ids)) g_feature_attr = g.copy() G = StellarGraph.from_networkx( g_feature_attr, node_features=reinex_node_embedding, node_type_default="n", edge_type_default="e" ) print(G.info()) train_subjects, test_subjects = model_selection.train_test_split( node_subjects, train_size=160, test_size=None, stratify=node_subjects ) val_subjects, test_subjects = model_selection.train_test_split( test_subjects, train_size=20, test_size=None, stratify=test_subjects ) train_subjects.value_counts().to_frame() target_encoding = preprocessing.LabelBinarizer() # target_encoding = preprocessing.OneHotEncoder() train_targets = target_encoding.fit_transform(train_subjects) val_targets = target_encoding.transform(val_subjects) test_targets = target_encoding.transform(test_subjects) generator = FullBatchNodeGenerator(G, method="gcn") train_gen = generator.flow(train_subjects.index, train_targets) val_gen = generator.flow(val_subjects.index, val_targets) test_gen = generator.flow(test_subjects.index, test_targets) all_nodes = node_subjects.index all_gen = generator.flow(all_nodes) return G, train_gen, train_targets, val_gen, val_targets, test_targets, test_gen, all_gen, generator
def build_graph(outfolder, app_data_list, nodes_path, edge_path): # with Client() as client, performance_report(os.path.join(outfolder, "performance_report.html")): # print(f"Dask Cluster: {client.cluster}") # print(f"Dashboard port: {client.scheduler_info()['services']['dashboard']}") data = dd.read_csv(list(app_data_list), dtype=str).compute() nodes = {} api_map = None # setup edges.csv pd.DataFrame(columns=['source', 'target']).to_csv(edge_path, index=False) for label in ['api', 'app', 'method', 'package']: print(f'Indexing {label}s') # uid_map = data[label].unique() uid_map = pd.DataFrame() uid_map[label] = data[label].unique() # if base_data is not None: # load base items # base_items = pd.read_csv( # os.path.join(base_data, label+'_map.csv'), # usecols=[label] # ) # uid_map = pd.concat([base_items, uid_map], ignore_index=True).drop_duplicates().reset_index(drop=True) uid_map['uid'] = label + pd.Series(uid_map.index).astype(str) uid_map = uid_map.set_index(label) uid_map.to_csv(os.path.join(outfolder, label+'_map.csv')) nodes[label] = IndexedArray(index=uid_map.uid.values) # get edges if not api if label == 'api': api_map = uid_map.uid # create api map else: print(f'Finding {label}-api edges') edges = data[[label, 'api']].drop_duplicates() edges[label] = edges[label].map(uid_map.uid) edges['api'] = edges['api'].map(api_map) edges.to_csv(edge_path, mode='a', index=False, header=False) del data # save nodes to file with open(nodes_path, 'wb') as file: pickle.dump(nodes, file) return StellarGraph(nodes = nodes, edges = pd.read_csv(edge_path))
def walks(self,walklen): G=nx.Graph(); G=nx.read_weighted_edgelist(self.dataset+"/krnmdata1/teamsG.txt") rw = BiasedRandomWalk(StellarGraph(G)) weighted_walks = rw.run( nodes=G.nodes(), # root nodes length=walklen, # maximum length of a random walk n=5, # number of random walks per root node p=0.1, # Defines (unormalised) probability, 1/p, of returning to source node q=2.0, # Defines (unormalised) probability, 1/q, for moving away from source node weighted=True, #for weighted random walks seed=42 # random seed fixed for reproducibility ) print("Number of random walks: {}".format(len(weighted_walks))) print(weighted_walks[0:10]) return weighted_walks
def createGraphFromCounter(dfg, mode='networkx'): transitionList = list(dfg) #transitionRow as series checkActivityList = [] G = nx.DiGraph() for i in transitionList: # if i[0] != i[1]: if i[0] not in checkActivityList: G.add_node(i[0], name=i[0]) checkActivityList.append(i[0]) if i[1] not in checkActivityList: G.add_node(i[1], name=i[1]) checkActivityList.append(i[1]) G.add_edge(i[0], i[1], weight=1) if mode == 'networkx': return G else: return StellarGraph.from_networkx(G)