def inference_on_list_gen(run,
graphs_path,
graph_list,
max_graphs=None,
get_sim_mat=False,
device='cpu',
batch_size=0):
"""
Same as before but one needs to provide a list of graphs name files in the annot path (of the form id_chunk_annot.p)
:param run:
:param graph_dir:
:param max_graphs:
:param get_sim_mat:
:param split_mode:
:param device:
:return:
"""
hparams = run_to_hparams(run)
if batch_size:
hparams.hparams.set('argparse', 'bathc_size', '1')
model = load_model(run)
inference_loader = loader_from_hparams(annotated_path=graphs_path,
hparams=hparams,
list_inference=graph_list)
loader = inference_loader.get_data()
gen = predict_gen(model,
loader,
max_graphs=max_graphs,
get_sim_mat=get_sim_mat,
device=device)
for stuff in gen:
yield stuff
def inference_on_list(run,
graphs_path,
graph_list,
max_graphs=None,
get_sim_mat=False,
nc_only=False,
device='cuda' if torch.cuda.is_available() else 'cpu'):
"""
Same as before but one needs to provide a list of graphs name files in the annot path (of the form id_chunk_annot.p)
:param run:
:param graph_dir:
:param max_graphs:
:param get_sim_mat:
:param split_mode:
:param device:
:return:
"""
hparams = run_to_hparams(run)
model = load_model(run)
inference_loader = loader_from_hparams(annotated_path=graphs_path,
hparams=hparams,
list_inference=graph_list)
loader = inference_loader.get_data()
model_outputs = predict(model,
loader,
max_graphs=max_graphs,
get_sim_mat=get_sim_mat,
nc_only=nc_only,
device=device)
return model_outputs
def inference_on_dir(run,
graph_dir,
ini=True,
max_graphs=10,
get_sim_mat=False,
split_mode='test',
nc_only=False,
device='cpu'):
"""
Load model and get node embeddings.
The results then need to be parsed as the order of the graphs is random and that the order of
each node in the graph is the messed up one (sorted)
Returns : embeddings and attributions, as well as 'g_inds':
a dict (graph name, node_id in sorted g_nodes) : index in the embedding matrix
:params
:get_sim_mat: switches off computation of rings and K matrix for faster loading.
:max_graphs max number of graphs to get embeddings for
"""
loader_mode = {'train': 0, 'test': 1, 'all': 2}
if ini:
hparams = run_to_hparams(run)
model = load_model(run)
loader = loader_from_hparams(graph_dir, hparams)
# No mat needed here
if not get_sim_mat:
loader.node_simfunc = None
loader = loader.get_data()[loader_mode[split_mode]]
else:
model, meta = meta_load_model(run)
loaders = meta_load_data(graph_dir,
meta,
get_sim_mat=get_sim_mat,
all_graphs=False)
loader = loaders[loader_mode[split_mode]]
model_outputs = predict(model,
loader,
max_graphs=max_graphs,
get_sim_mat=get_sim_mat,
nc_only=nc_only,
device=device)
return model_outputs
if args.ini is not None:
args.ini = os.path.join(script_dir, 'inis', f'{args.ini}.ini')
hparams = ConfParser(default_path=os.path.join(script_dir,
'inis/default.ini'),
path_to_ini=args.ini,
argparse=args)
# Hardware settings
# torch.multiprocessing.set_sharing_strategy('file_system')
device = torch.device(
f'cuda:{args.device}' if torch.cuda.is_available() else 'cpu')
# Dataloader creation
annotated_path = os.path.join(script_dir, '../data/annotated',
args.annotated_data)
loader = loader_from_hparams(annotated_path=annotated_path,
hparams=hparams)
hparams.add_value('argparse', 'num_edge_types', loader.num_edge_types)
train_loader, test_loader, all_loader = loader.get_data()
if len(train_loader) == 0 & len(test_loader) == 0:
raise ValueError('there are not enough points compared to the BS')
# Model and optimizer setup
model = model_from_hparams(hparams=hparams)
model = model.to(device)
if args.optim == 'sgd':
optimizer = optim.SGD(model.parameters(), lr=args.lr)
elif args.optim == 'adam':
optimizer = optim.Adam(model.parameters(), lr=args.lr)
# Experiment Setup