def main(trial): """ Parsing command line parameters. Creating target matrix. Fitting an SGCN. Predicting edge signs and saving the embedding. """ args = parameter_parser() # fix seed np.random.seed(args.seed) torch.manual_seed(args.seed) torch.cuda.manual_seed_all(args.seed) random.seed(args.seed) tab_printer(args) # read data edges = read_graph(args) trainer = SHIGTrainer(args, edges) trainer.setup_dataset() # training trainer.create_and_train_model(trial) if trial.should_prune(): raise optuna.exceptions.TrialPruned() if args.metric_to_optimize == 'AUC': return trainer.logs["performance"][-1][1] elif args.metric_to_optimize == 'F1': return trainer.logs["performance"][-1][2]
def main(): """ Parsing command line parameters, reading data. Fitting and scoring a funcGNN model. """ args = parameter_parser() tab_printer(args) trainer = funcGNNTrainer(args) trainer.fit()
def main(): """ Parsing command line parameters, processing graphs, fitting a CapsGNN. """ args = parameter_parser() tab_printer(args) model = CapsGNNTrainer(args) model.fit() model.score() model.save_predictions()
def main(): """ Parsing command line parameters, reading data, fitting EdMot and scoring the model. """ args = parameter_parser() tab_printer(args) graph = graph_reader(args.edge_path) model = EdMot(graph, args.components, args.cutoff) memberships = model.fit() membership_saver(args.membership_path, memberships)
def main(): """ Parsing command line parameters, reading data. Fitting and scoring a SEAL-CI model. """ args = parameter_parser() tab_printer(args) trainer = SEALCITrainer(args) trainer.fit() trainer.score()
def main(): """ Parsing command line parameters, processing graphs, fitting a GAM. """ args = parameter_parser() tab_printer(args) model = GAMTrainer(args) model.fit() model.score() model.save_predictions_and_logs()
def main(): """ Parsing command lines, creating target matrix. Fitting an Attention Walker and saving the embedding. """ args = parameter_parser() tab_printer(args) model = AttentionWalkTrainer(args) model.fit() model.save_model()
def main(): """ Parsing command lines, creating target matrix. Fitting SINE and saving the embedding. """ args = parameter_parser() tab_printer(args) model = SINETrainer(args) model.fit() model.save_embedding()
def main(): """ Parsing command line parameters, creating EgoNets. Creating a partition of the persona graph. Saving the memberships. """ args = parameter_parser() tab_printer(args) graph = graph_reader(args.edge_path) splitter = EgoNetSplitter(args.resolution) splitter.fit(graph) membership_saver(args.output_path, splitter.overlapping_partitions)
def main(): """ Parsing command line parameters, reading data. Fitting and scoring a SimGNN model. """ args = parameter_parser() tab_printer(args) trainer = SimGNNTrainer(args) trainer.fit() trainer.score() pickle.dump(trainer, open("simGNN.p", "wb"))
def main(): args = parameter_parser() tab_printer(args) if not os.path.exists('datasets'): print('Downloading datasets...') os.system( 'curl http://sami.haija.org/graph/datasets.tgz > datasets.tgz') os.system('tar zxvf datasets.tgz') solver = Solver(args) solver.train() solver.save()
def main(): """ Parsing command lines, creating target matrix, fitting BANE and saving the embedding. """ args = parameter_parser() tab_printer(args) P = read_graph(args) X = read_features(args) model = BANE(args, P, X) model.fit() model.save_embedding()
def main(): """ Parsing command line parameters, reading data, fitting an APPNP/PPNP and scoring the model. """ args = parameter_parser() torch.manual_seed(args.seed) tab_printer(args) graph = graph_reader(args.edge_path) features = feature_reader(args.features_path) target = target_reader(args.target_path) trainer = APPNPTrainer(args, graph, features, target) trainer.fit()
def execute_factorization(): """ Reading the target matrix, running optimization and saving to hard drive. """ args = parameter_parser() tab_printer(args) X = read_features(args.input_path) print("\nTraining started.\n") model = ADMM_NMF(X, args) model.optimize() print("\nFactors saved.\n") model.save_user_factors() model.save_item_factors()
def main(): """ Parsing command line parameters. Reading data, embedding base graph, creating persona graph and learning a splitter. Saving the persona mapping and the embedding. """ args = parameter_parser() torch.manual_seed(args.seed) tab_printer(args) graph = graph_reader(args.edge_path) trainer = SplitterTrainer(graph, args) trainer.fit() trainer.save_embedding() trainer.save_persona_graph_mapping()
def main(): """ Parsing command line parameters, reading data. Fitting and scoring a SimGNN model. """ args = parameter_parser() if path.isfile(args.saved_model): trainer = SimGNNTrainer(args) trainer.score() else: tab_printer(args) trainer = SimGNNTrainer(args) trainer.fit() trainer.score()
def main(): """ Parsing command line parameters, reading data. Fitting and scoring a SimGNN model. """ args = parameter_parser() tab_printer(args) trainer = SimGNNTrainer(args) if args.load_path: trainer.load() else: trainer.fit() trainer.score() if args.save_path: trainer.save()
def main(): """ Parsing command line parameters, reading data. Doing sparsification, fitting a GWNN and saving the logs. """ args = parameter_parser() tab_printer(args) graph = graph_reader(args.edge_path) features = feature_reader(args.features_path) target = target_reader(args.target_path) sparsifier = WaveletSparsifier(graph, args.scale, args.approximation_order, args.tolerance) sparsifier.calculate_all_wavelets() trainer = GWNNTrainer(args, sparsifier, features, target) trainer.fit() trainer.score() save_logs(args, trainer.logs)
def main(): """ Parsing command line parameters. Creating target matrix. Fitting an SGCN. Predicting edge signs and saving the embedding. """ args = parameter_parser() tab_printer(args) edges = read_graph(args) trainer = SignedGCNTrainer(args, edges) trainer.setup_dataset() trainer.create_and_train_model() if args.test_size > 0: trainer.save_model() score_printer(trainer.logs) save_logs(args, trainer.logs)
def main(): """ Parsing command line parameters. Creating target matrix. Fitting an SGCN. Predicting edge signs and saving the embedding. """ args = parameter_parser() avg_auc = [] avg_f1 = [] avg_precision = [] avg_recall = [] avg_acc = [] for x in range(int(args.num_runs)): print("Iteration: ", x) tab_printer(args) edges = read_graph(args) trainer = SignedGCNTrainer(args, edges) trainer.setup_dataset() trainer.create_and_train_model() if args.test_size > 0: trainer.save_model() score_printer(trainer.logs) save_logs(args, trainer.logs) avg_auc.append(score_printer(trainer.logs, avg='auc')[0]) print("This run's AUC: ", "%.3f" % (score_printer(trainer.logs, avg='auc')[0])) print('-----') avg_f1.append(score_printer(trainer.logs, avg='auc')[1]) avg_precision.append(score_printer(trainer.logs, avg='auc')[2]) avg_recall.append(score_printer(trainer.logs, avg='auc')[3]) avg_acc.append(score_printer(trainer.logs, avg='auc')[4]) print('AUC averaged over {} runs: '.format(args.num_runs), "%.3f" % np.mean(avg_auc)) print('F1 averaged over {} runs: '.format(args.num_runs), "%.3f" % np.mean(avg_f1)) print('Precision averaged over {} runs: '.format(args.num_runs), "%.3f" % np.mean(avg_precision)) print('Recall averaged over {} runs: '.format(args.num_runs), "%.3f" % np.mean(avg_recall)) print('Accuracy averaged over {} runs: '.format(args.num_runs), "%.3f" % np.mean(avg_acc)) print('Max AUC: ', "%.3f" % max(avg_auc), 'Max F1: ', "%.3f" % max(avg_f1), 'Max Precision: ', "%.3f" % max(avg_precision), \ 'Max Recall: ', "%.3f" % max(avg_recall), 'Max Accuracy', "%.3f" % max(avg_acc))
def main(): """ Parsing command line parameters, reading data. Fitting an NGCN and scoring the model. """ args = parameter_parser() torch.manual_seed(args.seed) tab_printer(args) graph = graph_reader(args.edge_path) features = feature_reader(args.features_path) target = target_reader(args.target_path) trainer = Trainer(args, graph, features, target, True) trainer.fit() if args.model == "mixhop": trainer.evaluate_architecture() args = trainer.reset_architecture() trainer = Trainer(args, graph, features, target, False) trainer.fit()
def main(): """ Parsing command line parameters, reading data, fitting a PDN and scoring the model. """ args = parameter_parser() torch.manual_seed(args.seed) tab_printer(args) reader = PathfinderDatasetReader(args.edges_path, args.node_features_path, args.edge_features_path, args.target_path) reader.read_dataset() reader.create_split(args.test_size, args.seed) dataset = reader.get_dataset() model = PathfinderDiscoveryNetwork(dataset["node_feature_count"], dataset["edge_feature_count"], dataset["classes"], args.node_filters, args.edge_filters) trainer = Trainer(args.epochs, args.learning_rate) trainer.train_model(model, dataset)
def main(): """ Parsing command line parameters. Creating target matrix. Fitting an SGCN. Predicting edge signs and saving the embedding. """ args = parameter_parser() tab_printer(args) args.edge_path = '../input/bitcoin_otc.csv' args.embedding_path = '../output/embedding/bitcoin_otc_sgcn.csv' args.features_path = './input/bitcoin_otc.csv' args.regression_weights_path = '../output/weights/bitcoin_otc_sgcn.csv' args.epochs = 1 edges = read_graph(args) # 导入训练数据 trainer = SignedGCNTrainer(args, edges) trainer.setup_dataset() # 计算特征 trainer.create_and_train_model() if args.test_size > 0: trainer.save_model() score_printer(trainer.logs) save_logs(args, trainer.logs)
"""Running GraRep""" from grarep import GraRep from param_parser import parameter_parser from utils import read_graph, tab_printer def learn_model(args): """ Method to create adjacency matrix powers, read features, and learn embedding. :param args: Arguments object. """ A = read_graph(args.edge_path) model = GraRep(A, args) model.optimize() model.save_embedding() if __name__ == "__main__": args = parameter_parser() tab_printer(args) learn_model(args)
def main(): """ Parsing command line parameters, reading data, fitting and scoring a SimGNN model. """ answer = input( "Are you sure you want to run the pipeline? Previous temp result files for the chosen dataset will be lost! (type yes)" ) if answer != 'yes': import sys sys.exit() # Parse and Print parameters args = param.parameter_parser() utils.tab_printer(args) dataset_name = args.dataset param.initGlobals(dataset_name) utils.clearDataFolder(param.temp_runfiles_path) # Initiate SimGnn Trainer trainer = SimGNNTrainer(args) use_pretrained = False # To determine whether a pre-trained model will be used. root = "../saved_model_state/" utils.fixpath(root) path = root + "general_simgnn_embSize{}.pt".format(trainer.embeddings_size) #TRAIN if use_pretrained is True: print( "Pre-trained mode: load an already fit state instead of training.") checkpoint = torch.load(path) trainer.model.load_state_dict(checkpoint['model_state_dict']) trainer.optimizer.load_state_dict(checkpoint['optimizer_state_dict']) else: trainer.fit() # I save the trained state to disk. torch.save( { 'model_state_dict': trainer.model.state_dict(), 'optimizer_state_dict': trainer.optimizer.state_dict() }, path) #TEST trainer.globalScore() # Vectorized scoring - can be skipped when using LSH if args.use_lsh: tuneLSH = False # To determine if LSH module will be utilized or examined. if tuneLSH: showLSHTablesDistributions(trainer, dataset_name, saveToFile=True) import sys sys.exit() else: lsh.makeLSHIndex(trainer) lsh.createBucketsWithNetworks(trainer, path) trainer.lshScore() if args.notify: import os, sys if sys.platform == 'linux': os.system('notify-send SimGNN "Program is finished.') elif sys.platform == 'posix': os.system( """osascript -e 'display notification "SimGNN" with title "Program is finished."' """) else: raise NotImplementedError('No support for this OS.') mainResults(dataset_name, args.use_lsh)
def __init__(self, in_channels, out_channels, norm=True, norm_embed=True, bias=True): super(SignedSAGEConvolution, self).__init__() self.args = parameter_parser() self.edge_feature_type = all_edge_features self.pca_ = pca_ if(self.pca_): self.edge_feature_type = [x for x in edge_features.columns if 'user1' not in x and 'user2' not in x] self.in_channels = in_channels self.out_channels = out_channels self.norm = norm self.norm_embed = norm_embed self.weight = Parameter(torch.Tensor(self.in_channels, out_channels)) self.multihead_attn = torch.nn.MultiheadAttention(embed_dim = node_features.shape[1], dropout=.01, num_heads= 1) self.multihead_attn_dp = torch.nn.MultiheadAttention(embed_dim = self.out_channels, dropout=0.01, num_heads = 1) self.multihead_attn_dn = torch.nn.MultiheadAttention(embed_dim = self.out_channels, dropout=0.01, num_heads = 1) if(self.pca_): self.multihead_attn = torch.nn.MultiheadAttention(embed_dim = n_components, dropout=.01, num_heads= 1) self.multihead_attn_d = torch.nn.MultiheadAttention(embed_dim = self.out_channels, dropout=0.01, num_heads = 1) self.msk = torch.from_numpy(m).float().to(device) """ True False------------------------------- """ self.msk_flag_dp = True self.msk_flag_dn = True if(self.args.edge_features_incls): self.include_edge_features = True if(not self.args.edge_features_incls): self.include_edge_features = False if(self.args.attention_include): self.include_attention = True if(not self.args.attention_include): self.include_attention = False self.edges_pool_flag = True self.big_mask = torch.from_numpy(m).float().to(device) # Overall mask of edges if(self.include_attention and self.include_edge_features): self.weight = Parameter(torch.Tensor(self.in_channels + 4*len(self.edge_feature_type), out_channels)) self.multihead_attn_a = torch.nn.MultiheadAttention(embed_dim = self.weight.shape[1], dropout=0.01, num_heads = 1) if(self.include_attention and not self.include_edge_features): self.weight = Parameter(torch.Tensor(self.in_channels, out_channels)) self.multihead_attn_a = torch.nn.MultiheadAttention(embed_dim = self.weight.shape[1], dropout=0.01, num_heads = 1) if(not self.include_attention and self.include_edge_features): self.weight = Parameter(torch.Tensor(self.in_channels + 4*len(self.edge_feature_type), out_channels)) self.multihead_attn_a = torch.nn.MultiheadAttention(embed_dim = self.weight.shape[1], dropout=0.01, num_heads = 1) if(not self.include_attention and not self.include_edge_features): self.weight = Parameter(torch.Tensor(self.in_channels , out_channels)) # + node_features.shape[1] self.multihead_attn_a = torch.nn.MultiheadAttention(embed_dim = self.weight.shape[1], dropout=0.01, num_heads = 1) if bias: self.bias = Parameter(torch.Tensor(out_channels)) else: self.register_parameter("bias", None) edge_features_pooled_out = [] edge_features_pooled_in = [] for xe in set(edge_features.index.get_level_values(0)).union(set(edge_features.index.get_level_values(1))): tmp = edge_features.query("user1 == {}".format(xe)) if(len(tmp) == 0): tmp.loc[0] = [0]*tmp.shape[1] edge_features_pooled_out.append(tmp.loc[:,self.edge_feature_type].max().values) for xe in set(edge_features.index.get_level_values(0)).union(set(edge_features.index.get_level_values(1))): tmp = edge_features.query("user2 == {}".format(xe)) if(len(tmp) == 0): tmp.loc[0] = [0]*tmp.shape[1] edge_features_pooled_in.append(tmp.loc[:,self.edge_feature_type].max().values) self.edge_features_pooled_out = torch.from_numpy(np.array(edge_features_pooled_out)).float().to(device) self.edge_features_pooled_in = torch.from_numpy(np.array(edge_features_pooled_in)).float().to(device) self.reset_parameters()
def get_args(): args = parameter_parser() args.Baseline_num = len(args.Baselines) return args
args = vars(args) keys = sorted(args.keys()) tab = Texttable() tab.add_rows([["Parameter", "Value"]]) tab.add_rows([[k.replace("_", " ").capitalize(), args[k]] for k in keys]) print(tab.draw()) def read_graph(settings): """ Reading the edge list from the path and returning the networkx graph object. :param path: Path to the edge list. :return graph: Graph from edge list. """ if settings.edgelist_input: graph = nx.read_edgelist(settings.input) else: edge_list = pd.read_csv(settings.input).values.tolist() graph = nx.from_edgelist(edge_list) graph.remove_edges_from(nx.selfloop_edges(graph)) return graph if __name__ == "__main__": settings = parameter_parser() tab_printer(settings) G = read_graph(settings) machine = WaveletMachine(G, settings) machine.create_embedding() machine.transform_and_save_embedding()
def loop_run(): args = parameter_parser() argument_printer(args) create_and_run_model(args)