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)
