def find_new_alignment_rel(self):
t = time.time()
un_aligned_ent1 = self.kgs.valid_entities1 + self.kgs.test_entities1
un_aligned_ent2 = self.kgs.valid_entities2 + self.kgs.test_entities2
embeds1 = tf.nn.embedding_lookup(self.ent_embeds, un_aligned_ent1).eval(session=self.session)
embeds2 = tf.nn.embedding_lookup(self.ent_embeds, un_aligned_ent2).eval(session=self.session)
mapping_mat = self.mapping_mat.eval(session=self.session)
embeds1 = np.matmul(embeds1, mapping_mat)
sim_mat = sim(embeds1, embeds2, normalize=True)
print("find new alignment based on relational embeddings:")
new_alignment_rel_index = find_potential_alignment_greedily(sim_mat, self.sim_th)
check_new_alignment(new_alignment_rel_index)
if new_alignment_rel_index is None or len(new_alignment_rel_index) == 0:
return False
stop = False
if len(self.new_alignment_index) == 0:
self.new_alignment_index = set(new_alignment_rel_index)
elif len(set(new_alignment_rel_index) - self.new_alignment_index) == 0:
stop = True
else:
self.new_alignment_index |= set(new_alignment_rel_index)
stop = False
check_new_alignment(self.new_alignment_index, context='check total new alignment')
self.new_alignment = [(un_aligned_ent1[x], un_aligned_ent2[y]) for (x, y) in self.new_alignment_index]
# del embeds1, embeds2, sim_mat
print('finding new alignment costs time: {:.4f}s'.format(time.time() - t))
return stop
def launch_alignment_training_1epo(self, epoch):
t1 = time.time()
sim_mat = self._ref_sim_mat()
pairs = find_potential_alignment_greedily(sim_mat, self.args.sim_th)
if pairs is None or len(pairs) == 0:
return
new_ent1 = [self.ref_entities1[pair[0]] for pair in pairs]
new_ent2 = [self.ref_entities2[pair[1]] for pair in pairs]
tr_ws = [sim_mat[pair[0], pair[1]] for pair in pairs]
newly_triples = generate_triples_of_latent_ents(self.kgs, new_ent1, new_ent2, tr_ws)
steps = math.ceil(((len(newly_triples)) / self.args.batch_size))
if steps == 0:
steps = 1
alignment_loss = 0
for step in range(steps):
newly_pos_batch, newly_neg_batch = generate_triple_batch(newly_triples, self.args.batch_size,
self.kgs.kg1.entities_list +
self.kgs.kg2.entities_list)
alignment_fetches = {"loss": self.alignment_loss, "train_op": self.alignment_optimizer}
alignment_feed_dict = {self.new_ph: [tr[0] for tr in newly_pos_batch],
self.new_pr: [tr[1] for tr in newly_pos_batch],
self.new_pt: [tr[2] for tr in newly_pos_batch],
self.new_nh: [tr[0] for tr in newly_neg_batch],
self.new_nr: [tr[1] for tr in newly_neg_batch],
self.new_nt: [tr[2] for tr in newly_neg_batch],
self.tr_weight: [tr[3] for tr in newly_pos_batch]}
alignment_vals = self.session.run(fetches=alignment_fetches, feed_dict=alignment_feed_dict)
alignment_loss += alignment_vals["loss"]
alignment_loss /= len(newly_triples)
print('epoch {}, alignment loss: {:.4f}, cost time: {:.4f}s'.format(epoch, alignment_loss, time.time() - t1))