def evaluate_conv(args, unique_entities):
model_conv = SpKBGATConvOnly(entity_embeddings, relation_embeddings, args.entity_out_dim, args.entity_out_dim,
args.drop_GAT, args.drop_conv, args.alpha, args.alpha_conv,
args.nheads_GAT, args.out_channels)
model_conv = nn.DataParallel(model_conv)
if CUDA:
model_conv.load_state_dict(torch.load(
'{0}conv/trained_{1}.pth'.format(args.output_folder, args.epochs_conv - 1)))
model_conv.cuda()
else:
model_conv.load_state_dict(torch.load(
'{0}conv/trained_{1}.pth'.format(args.output_folder, args.epochs_conv - 1), map_location=torch.device('cpu')))
model_conv.eval()
with torch.no_grad():
if isinstance(model_conv, nn.DataParallel):
### original code is get_validation_pred
Corpus_.get_validation_pred_relation(args, model_conv.module, unique_entities)
else:
Corpus_.get_validation_pred_relation(args, model_conv, unique_entities)
if isinstance(model_conv, nn.DataParallel):
Corpus_.get_validation_pred(args, model_conv.module, unique_entities)
else:
Corpus_.get_validation_pred(args, model_conv, unique_entities)
def evaluate_conv(args, unique_entities, load_model):
CUDA = torch.cuda.is_available()
model_conv = SpKBGATConvOnly(entity_embeddings, relation_embeddings,
args.entity_out_dim, args.entity_out_dim,
args.drop_GAT, args.drop_conv, args.alpha,
args.alpha_conv, args.nheads_GAT,
args.out_channels)
model_conv = nn.DataParallel(model_conv)
if CUDA:
model_conv.load_state_dict(torch.load(load_model))
model_conv.cuda()
else:
model_conv.load_state_dict(torch.load(load_model),
map_location=torch.device('cpu'))
model_conv.eval()
with torch.no_grad():
if isinstance(model_conv, nn.DataParallel):
Corpus_.get_validation_pred_relation(args, model_conv.module,
unique_entities)
else:
Corpus_.get_validation_pred_relation(args, model_conv,
unique_entities)
if isinstance(model_conv, nn.DataParallel):
Corpus_.get_validation_pred(args, model_conv.module,
unique_entities)
else:
Corpus_.get_validation_pred(args, model_conv, unique_entities)
def evaluate_conv(args, unique_entities_train, unique_entities_test):
global initial_entity_emb_params
global entity_embeddings
model_gat = SpKBGATModified(entity_embeddings, relation_embeddings,
args.entity_out_dim, args.entity_out_dim,
args.drop_GAT, args.alpha, args.nheads_GAT,
initial_entity_emb_params)
model_gat.load_state_dict(
torch.load('{0}trained_{1}.pth'.format(args.output_folder, 0)))
model_entity_embedding = EntityEmbedding( initial_entity_emb_params['entity_embed_dim_in'], \
initial_entity_emb_params['hidden_dim_entity'], \
initial_entity_emb_params['num_encoder_layers_entity'], \
initial_entity_emb_params['is_bidirectional'], \
initial_entity_emb_params['drop_out_rate'], \
initial_entity_emb_params['hidden_dim_entity'], \
initial_entity_emb_params['entity_embed_dim_out'], \
initial_entity_emb_params['entity_conv_filter_size'],
initial_entity_emb_params['word_vocab'], \
initial_entity_emb_params['word_embed_dim'], \
initial_entity_emb_params['char_embed_dim'], \
initial_entity_emb_params['word_embed_matrix'], \
initial_entity_emb_params['char_feature_size'], \
initial_entity_emb_params['conv_filter_size'], \
initial_entity_emb_params['max_word_len_entity'], \
initial_entity_emb_params['char_vocab'])
model_entity_embedding.load_state_dict(
torch.load('{0}{1}/trained_{2}.pth'.format(args.output_folder,
'entity_embeddings', 0)))
model_conv = SpKBGATConvOnly(entity_embeddings, relation_embeddings,
args.entity_out_dim, args.entity_out_dim,
args.drop_GAT, args.drop_conv, args.alpha,
args.alpha_conv, args.nheads_GAT,
args.out_channels)
model_conv.load_state_dict(
torch.load('{0}conv/trained_{1}.pth'.format(args.output_folder, 0)))
if CUDA:
model_conv.cuda()
model_gat.cuda()
model_entity_embedding.cuda()
model_conv.eval()
model_gat.eval()
model_entity_embedding.eval()
with torch.no_grad():
Corpus_.get_validation_cnfmat(args,
model_gat,
model_entity_embedding,
model_conv,
unique_entities_train,
unique_entities_test,
reuse=False,
gat_only=False)
def evaluate_conv(args, unique_entities):
model_conv = SpKBGATConvOnly(entity_embeddings, relation_embeddings, args.entity_out_dim, args.entity_out_dim,
args.drop_GAT, args.drop_conv, args.alpha, args.alpha_conv,
args.nheads_GAT, args.out_channels)
model_conv.load_state_dict(torch.load(
'{0}conv/trained_{1}.pth'.format(args.output_folder, args.epochs_conv - 1)))
model_conv.cuda()
with torch.no_grad():
Corpus_.get_validation_pred(args, model_conv, unique_entities)
def evaluate_conv(args, unique_entities):
model_conv = SpKBGATConvOnly(entity_embeddings, relation_embeddings,
args.entity_out_dim, args.entity_out_dim,
args.drop_GAT, args.drop_conv, args.alpha,
args.alpha_conv, args.nheads_GAT,
args.out_channels)
model_conv.load_state_dict(
torch.load('{0}conv/trained_{1}.pth'.format(args.output_folder,
args.epochs_conv - 1)))
model_conv.cuda()
model_conv.eval()
with torch.no_grad():
preds = Corpus_.get_validation_pred(args, model_conv, unique_entities)
data_path = "/home/harsha1/Desktop/pLogicNet/data/wn18rr/"
entity2id = read_entity_from_id(data_path + 'entity2id.txt')
relation2id = read_relation_from_id(data_path + 'relation2id.txt')
id2entity = {v: k for k, v in entity2id.items()}
id2relation = {v: k for k, v in relation2id.items()}
is_unweigted = False
directed = True
work_path = args.work_path
cand_triples, train_adjacency_mat, unique_entities_test = load_data1(
os.path.join(work_path, 'hidden.txt'), entity2id, relation2id,
is_unweigted, directed)
scores = infer_step(model_conv, cand_triples, args)
with open(work_path + '/annotation.txt', 'w') as fo:
for (h, r, t), s in zip(cand_triples, scores):
fo.write('{}\t{}\t{}\t{}\n'.format(id2entity[h], id2relation[r],
id2entity[t], s))
with open(work_path + '/pred_kge.txt', 'w') as fo:
print(len(preds))
i = 0
for value in preds:
if len(value) == 3:
continue
else:
i = i + 1
h, r, t, f, rk, l = value
fo.write('{}\t{}\t{}\t{}\t{}\n'.format(id2entity[h],
id2relation[r],
id2entity[t], f, rk))
#print(i)
for e, val in l:
fo.write('{}:{:.12f} '.format(id2entity[e], val))
fo.write('\n')
def evaluate_conv(args, unique_entities):
model_conv = SpKBGATConvOnly(
initial_entity_emb=entity_embeddings,
initial_relation_emb=relation_embeddings,
entity_out_dim=args.entity_out_dim,
relation_out_dim=args.entity_out_dim,
drop_GAT=args.drop_GAT,
drop_conv=args.drop_conv,
alpha=args.alpha,
alpha_conv=args.alpha_conv,
nheads_GAT=args.nheads_GAT,
conv_out_channels=args.out_channels,
)
model_conv.load_state_dict(
torch.load("{0}conv/trained_{1}.pth".format(args.output_folder,
args.epochs_conv - 1)),
strict=False,
)
if CUDA:
model_conv.cuda()
model_conv.eval()
with torch.no_grad():
Corpus_.get_validation_pred(args, model_conv, unique_entities)
def train_conv(args):
# Creating convolution model here.
####################################
print("Defining model")
if args.tanh:
model_gat = SpKBGATModified(entity_embeddings, relation_embeddings, args.entity_out_dim, args.entity_out_dim,
args.drop_GAT, args.alpha, args.nheads_GAT, 'tanh')
else:
model_gat = SpKBGATModified(entity_embeddings, relation_embeddings, args.entity_out_dim, args.entity_out_dim,
args.drop_GAT, args.alpha, args.nheads_GAT, 'leakyrelu')
print("Only Conv model trained")
model_conv = SpKBGATConvOnly(entity_embeddings, relation_embeddings, args.entity_out_dim, args.entity_out_dim,
args.drop_GAT, args.drop_conv, args.alpha, args.alpha_conv,
args.nheads_GAT, args.out_channels)
model_gat = nn.DataParallel(model_gat)
model_conv = nn.DataParallel(model_conv)
if CUDA:
model_conv.cuda()
model_gat.cuda()
# load gat weights given pretrained
if (args.load_gat is None) or (args.load_gat is not None and args.epochs_gat > 0):
model_gat.load_state_dict(torch.load(
'{0}gat/trained_{1}.pth'.format(args.output_folder, args.epochs_gat - 1)))
else:
model_gat.load_state_dict(torch.load(args.load_gat))
if isinstance(model_conv, nn.DataParallel):
if args.load_conv is None:
model_conv.module.final_entity_embeddings = model_gat.module.final_entity_embeddings
model_conv.module.final_relation_embeddings = model_gat.module.final_relation_embeddings
else:
model_conv.load_state_dict(torch.load(args.load_conv))
else:
model_conv.final_entity_embeddings = model_gat.final_entity_embeddings
model_conv.final_relation_embeddings = model_gat.final_relation_embeddings
Corpus_.batch_size = args.batch_size_conv
Corpus_.invalid_valid_ratio = int(args.valid_invalid_ratio_conv)
optimizer = torch.optim.Adam(
model_conv.parameters(), lr=args.lr, weight_decay=args.weight_decay_conv)
scheduler = torch.optim.lr_scheduler.StepLR(
optimizer, step_size=25, gamma=0.5, last_epoch=-1)
margin_loss = torch.nn.SoftMarginLoss()
epoch_losses = [] # losses of all epochs
print("Number of epochs {}".format(args.epochs_conv))
for epoch in range(args.epochs_conv):
print("\nepoch-> ", epoch)
random.shuffle(Corpus_.train_triples)
Corpus_.train_indices = np.array(
list(Corpus_.train_triples)).astype(np.int32)
model_conv.train() # getting in training mode
start_time = time.time()
epoch_loss = []
if len(Corpus_.train_indices) % args.batch_size_conv == 0:
num_iters_per_epoch = len(
Corpus_.train_indices) // args.batch_size_conv
else:
num_iters_per_epoch = (
len(Corpus_.train_indices) // args.batch_size_conv) + 1
for iters in range(num_iters_per_epoch):
start_time_iter = time.time()
train_indices, train_values = Corpus_.get_iteration_batch(iters)
if CUDA:
train_indices = Variable(
torch.LongTensor(train_indices)).cuda()
train_values = Variable(torch.FloatTensor(train_values)).cuda()
else:
train_indices = Variable(torch.LongTensor(train_indices))
train_values = Variable(torch.FloatTensor(train_values))
preds = model_conv(
Corpus_, Corpus_.train_adj_matrix, train_indices)
optimizer.zero_grad()
loss = margin_loss(preds.view(-1), train_values.view(-1))
loss.backward()
for param in model_conv.parameters():
param.grad.data.clamp_(-1, 1)
optimizer.step()
epoch_loss.append(loss.data.item())
end_time_iter = time.time()
line = "Iteration-> {0} , Iteration_time-> {1:.4f} , Iteration_loss {2:.4f}".format(
iters, end_time_iter - start_time_iter, loss.data.item())
print(line)
write_to_file(args, line)
scheduler.step()
line = "Epoch {} , average loss {} , epoch_time {}".format(
epoch, sum(epoch_loss) / len(epoch_loss), time.time() - start_time)
epoch_losses.append(sum(epoch_loss) / len(epoch_loss))
print(line)
write_to_file(args, line)
save_model(model_conv, args.data, epoch,
args.output_folder + "conv/")
