def write_vectors(vectors, output_filename):
logger.info("Writing vectors to %s" % output_filename)
with codecs.open(output_filename, "w") as output_file:
for t in vectors:
output_file.write('\t'.join(map(str,t)))
output_file.write('\n')
logger.info("Done writing vectors to %s" % output_filename)
def strings2ids_from_file(self,
input_filename,
output_filename=None,
column_offset=0):
logger.info("encode triples from %s \n\t save to %s" %
(input_filename, output_filename))
self.strings2ids(FileTriplesSource(input_filename, column_offset),
output_filename)
def adapt(self, new_triples):
super().adapt(new_triples)
logger.info("Retrain model and save to %s" %
self.get_current_model_folder())
self.curr_model = self.train(
JointTriplesSource(self.kg_triples, new_triples))
logger.info("Done retraining model and save to %s !" %
self.get_current_model_folder())
def dump_dict(dict_to_dump,dict_filename, overwrite):
if overwrite or not os.path.exists(dict_filename):
logger.info("Dump to %s" % dict_filename)
with codecs.open(dict_filename, "w") as output_file:
output_file.write(str(len(dict_to_dump.keys())) + '\n')
for k, v in dict_to_dump.items():
output_file.write(str(k) + '\t' + str(v) + '\n')
return True
return False
def write_triples_as_predicates(triples_iteratable, output_filename, surround=False):
logger.info("Writing triples to %s" % output_filename)
with codecs.open(output_filename, "w") as output_file:
for t in triples_iteratable:
if surround:
t=map(add_arrows,t)
output_file.write('%s(%s,%s)'%(t[1],t[0],t[2]))
output_file.write('\n')
logger.info("Done writing triples to %s" % output_filename)
def train(self, triples, is_update=False):
logger.info("Train a model using OpenKE TF!")
self._prepare_training_data(triples)
new_model = train_model(self._get_data_folder(),
self.get_current_model_folder(),
self.model_name)
logger.info("Done Training a model using OpenKE TF! (%s)" %
self.model_name)
return new_model
def end_process(self):
"""
Perform basic operations at the end
:return:
"""
logger.info("Plotting Results!")
evals=[i.eval for i in self.iterations]
if all(evals):
eval_utils.plot_iterations(evals, self.itr_stats_plot_file)
logger.info("Done Plotting Results!")
def adapt(self, new_feedback_triples: TriplesSource):
"""
Adapt the emebdding model using the new set of Auxilary triples
:param new_feedback_triples: the auxilary triples
:return:
"""
self.iteration_num += 1
self.feedback_triples_history.append(new_feedback_triples)
logger.info('Triples used for adaptation: %s' %
new_feedback_triples.get_name())
def load_saved_model(input_data_folder, model_tf_filepath, model='TransE'):
input_data_folder += '/'
logger.info("loading trained model from %s" % model_tf_filepath)
con = config.Config()
con.set_in_path(input_data_folder)
con.set_import_files(model_tf_filepath)
con.init()
# con.set_model(models.TransE)
eval('con.set_model(models.%s)' % model)
embeddings = con.get_parameters("numpy")
logger.info("Done loading trained model!")
return embeddings
def explain(self):
logger.info("Explaining clusters !")
# self.clusters_explainer.prepare_data(self.current_itr.entity_clusters_triples)
# clusters = self.current_itr.entity_clusters_triples.get_uniq_labels()
# explanations_dict = self.clusters_explainer.explain(clusters)
clusters2explanations_dict = self.clusters_explainer.explain(self.current_itr.entity_clusters_triples)
if self.save_steps:
output_file = os.path.join(self.get_current_itr_directory(), 'explanations.txt')
dump_explanations_to_file(clusters2explanations_dict, output_file)
logger.info("Done Explaining clusters!")
return clusters2explanations_dict
def initialize(self):
"""
Load the base model or train a new one if does not exist.
The basemodel is loaded to current_model and base_model variables
:return: none
"""
# flag_file = os.path.join(self._get_current_model_folder(), 'model.vec.tf.index')
embedding_model_file = self.get_current_model_filepath()
if not self.is_trained():
logger.warning("File %s does not exist!" % embedding_model_file)
logger.warning("Training the model will start from scratch!")
self.base_model = self.train(self.kg_triples)
logger.warning("Done training the model will start from scratch!")
else:
logger.info('Loading Model from %s' %
self.get_current_model_filepath())
# loaded_model =
# if not self.base_model:
self.base_model = self.load_from_file()
logger.info('Done Loading Model!')
logger.info('copy model to new folder: %s' % self.embedding_folder)
copytree(self.get_current_model_folder(),
os.path.join(self.embedding_folder, 'base'))
logger.info('Done copy model to new folder: %s' %
self.embedding_folder)
self.curr_model = self.base_model
def get_entities_embedding(self, entities):
entities_ids = self.kg_encoder.conv_entities2ids(entities)
logger.info("Get entities ids!")
# with open('/GW/D5data-11/gadelrab/ExDEC/results/yago_old/entities_encoded.tsv', 'w') as tmp_file:
# for e,i in zip(entities,entities_ids):
# tmp_file.write('%s\t%s\n'%(e,i))
entities_vectors = self.curr_model['ent_embeddings']
target_embedding_vec = np.array(
[entities_vectors[i] for i in entities_ids])
# logger.info("Data type ... "+str(target_embedding_vec.dtype)+" "+str(target_embedding_vec.shape))
# np.savetxt('/GW/D5data-11/gadelrab/ExDEC/results/yago_old/data_embedding.tsv', target_embedding_vec,
# delimiter="\t")
print("embedding shape from adapter " +
str(target_embedding_vec.shape))
return target_embedding_vec
def construct_feedback(self):
logger.info("Construct Feedback Triples!")
output_file=None
if self.save_steps:
output_file = os.path.join(self.get_current_itr_directory(), 'feedback_triples.tsv')
triples = self.augmentation_strategy.get_augmentation_triples(
descriptions = self.current_itr.clusters_explanations_dict,
target_entities= self.current_itr.entity_clusters_triples,
output_file=output_file,
iter_num=self.current_itr.id)
if self.save_steps:
write_triples(triples, output_file)
logger.info("Done Constructing Feedback Triples!")
return triples
def plot_iterations(results_list, output_file=None):
"""
Plot the clustering and explanations quality results over the oterations.
:param results_list:
:param output_file:
:return:
"""
markers = ['.', '*', 'x', 's', 'p', '+', 'h', 'o']
plt.rcParams.update({'font.size': 16})
if len(results_list) == 0:
print("NO Results skip plotting!")
return
df = pd.DataFrame(results_list)
plt.clf()
ax = plt.gca()
names = {'x_coverage': 'Exc', 'wr_acc': 'WRA'}
for met, mar in zip(metrics_to_plot, markers):
lb = met.replace('@1', '')
lb = names[lb] if lb in names else lb
if met in df.columns:
df.plot(kind='line',
x='itr_num',
y=met,
ax=ax,
marker=mar,
label=lb)
plt.xlabel(None)
plt.grid(b=True, axis='y')
# plt.legend(loc=9)
plt.yticks([a / 10 for a in range(0, 11)])
plt.xticks(range(0, 10))
plt.ylim(0, 1.05)
plt.xlim(0, 9.5)
if output_file:
logger.info("Saving plot to %s" % output_file)
plt.tight_layout()
plt.savefig(output_file)
else:
plt.show()
def index_triples(self,
triples_source: TriplesSource,
prefix='',
safe_urls=False,
drop_old=False):
if drop_old:
logger.info("Drop %s " % self.identifier)
self.drop()
if self.store != 'SPARQLUpdateStore' and not self.graph:
self.graph = Graph(store=self.store, identifier=self.identifier)
# print(self.graph.store)
# if self.store == 'SPARQLUpdateStore':
# self.graph.open(self.endpoint)
# self._index(triples_source, prefix, safe_urls)
self._index_np(triples_source) # , prefix, safe_urls)
return self.graph
def cluster(self):
logger.info("Start clustering")
entity_vectors = self.current_itr.target_entities_embeddings
logger.debug(entity_vectors)
logger.info("size of the data " + str(entity_vectors.shape))
y_pred = self.clustering_method.cluster(entity_vectors, clustering_params=self.clustering_params,
output_folder=self.get_current_itr_directory())
triples = EntityLabelsToTriples(np.column_stack((self.target_entities.get_entities(), y_pred.reshape(-1, 1))),
iter_id=self.current_itr.id)
if self.save_steps:
output_file = os.path.join(self.get_current_itr_directory(), 'clustering.tsv')
output_vecs_file = os.path.join(self.get_current_itr_directory(), 'embeddings_vecs.tsv')
write_triples(triples, output_file)
write_vectors(entity_vectors, output_vecs_file)
output_labels_file = os.path.join(self.get_current_itr_directory(), 'clustering_labels_only.tsv')
write_vectors(y_pred.reshape(-1,1), output_labels_file)
return triples
def _prepare_training_data(self, triples, overwrite=False):
logger.info("Prepare embedding training data!")
triples_filepath = os.path.join(self._get_data_folder(),
'triple2id.txt')
if overwrite or not os.path.exists(triples_filepath):
self.kg_encoder.strings2ids(triples, triples_filepath)
training_data_filepath = os.path.join(self._get_data_folder(),
'train2id.txt')
if overwrite or not os.path.exists(training_data_filepath):
convert_ere2eer(triples_filepath, training_data_filepath)
self.kg_encoder.dump_dicts(self._get_data_folder())
# files required by openKE
create_dummy_valid_test_files(self._get_data_folder())
generate_cosntraints_openKE(self._get_data_folder())
logger.info("Done preparing training data!")
def write_triples(triples_iteratable, output_filename, surround=False, unquote_urls=True):
"""
Exports triples from a source to file as tsv.
:param unquote_urls:
:param triples_iteratable:
:param output_filename:
:param surround:
:return:
"""
logger.info("Writing triples to %s" % output_filename)
with codecs.open(output_filename, "w") as output_file:
for t in triples_iteratable:
if unquote_urls:
t=map(unquote,t)
if surround:
t=map(add_arrows,t)
output_file.write('\t'.join(t))
output_file.write('\n')
logger.info("Done writing triples to %s" % output_filename)
def __init__(self,
filepath,
column_offset=0,
prefix='',
safe_urls=False,
delimiter='\s+'):
super(FileTriplesSource, self).__init__(name=filepath)
self.prefix = prefix
self.safe_urls = safe_urls
self.column_offset = column_offset
self.filepath = filepath
s = time.process_time()
self.data = pd.read_csv(self.filepath,
header=None,
delimiter=delimiter,
dtype=str).values
self.data = self.data[:, :3]
en = time.process_time()
logger.info("Done loading data! size: %s time: %f s" %
(str(self.data.shape), (en - s)))
valid_id = np.vectorize(data_formating.valid_id)
# invalid_rows=np.where( np.bitwise_not(valid_id(self.data[:])) )[0]
# print(invalid_rows)
self.data = np.delete(
self.data,
np.unique(np.where(np.bitwise_not(valid_id(self.data[:])))[0]),
axis=0)
if safe_urls or prefix:
self.data = parallel_apply_along_axis(format_triple,
1,
self.data,
prefix=self.prefix,
quote_it=self.safe_urls)
logger.info(
"Done fixing data formatting and filtering! size: %s time: %f s" %
(str(self.data.shape), (time.process_time() - en)))
def explain(self, clusters=None, in_file=None, output_file=None):
logger.info("Explaining using Dedalo for " + in_file)
for cl in clusters:
for explanation in ddl.explain(self.kg_hdt_file,
in_file,
minimum_score=0.2,
groupid=cl):
logger.info(explanation)
logger.info("Done Explaining!")
def adapt(self, new_feedback_triples):
super().adapt(new_feedback_triples)
logger.info("Retrain model and save to %s" %
self.get_current_model_folder())
update_data = self.prepare_adaptation_data()
logger.info("Update Data: %s size: %i" %
(update_data.get_name(), update_data.size()))
is_update = not self.update_mode == UpdateMode.RETRAIN
self.curr_model = self.train(update_data, is_update=is_update)
logger.info("Done retraining model and save to %s !" %
self.get_current_model_folder())
def _index_np(self, triples_source, prefix='', safe_urls=False):
logger.info("Start indexing " + triples_source.get_name())
data = triples_source.as_numpy_array()
data_size = triples_source.size()
number_splits = math.ceil(data_size / self.batch_size)
logger.info("data size %i" % data_size)
logger.info("chunks %i" % number_splits)
# ch=0
chunks = np.array_split(data, number_splits)
for chunk in tqdm(chunks):
if self.store == 'SPARQLUpdateStore':
self.insert_sparql(chunk)
else:
self.insert_memory(chunk)
logger.info("Done indexing " + triples_source.get_name())
def train(self, triples, is_update=False):
logger.warning("Training may take long time!")
training_array = self._prepare_training_data(triples)
logger.info("Start Training!")
if not is_update:
logger.info("Fitting from scratch!")
trained_model = self._get_model(is_update=False)
else:
logger.info("Continuous training!")
trained_model = self._get_model(is_update=True)
if self.update_mode == UpdateMode.ADAPT_RESTART:
trained_model.copy_old_model_params(self.base_model)
elif self.update_mode == UpdateMode.ADAPT_PROGRESSIVE:
trained_model.copy_old_model_params(self.curr_model)
trained_model.fit(training_array, continue_training=is_update)
save_model(trained_model,
model_name_path=self.get_current_model_filepath())
logger.info("Done Training model!")
return trained_model
def strings2ids(self, triples_source, output_filename=None):
logger.info("Encode triples and save to %s" % (output_filename))
with codecs.open(output_filename, "w") as output_file:
# triples_as_list = list(triples_source.triples())
# output_file.write(str(len(triples_as_list)) + '\n')
# triples_as_list = list(triples_source.triples())
output_file.write(str(triples_source.size()) + '\n')
logger.info("Encoding %i triples!" % triples_source.size())
for t in triples_source:
encoded_t = (self._entity2id(t[0]), self._relation2id(t[1]),
self._entity2id(t[2]))
output_file.write('\t'.join([str(c)
for c in encoded_t]) + '\n')
logger.info("Done encoding triples!")
return output_filename
def maximum_assignments(y_true_str, y_pred, show_confusion_matrix):
w = consruct_confusion_matrix(y_true_str, y_pred)
row_ind, col_ind = linear_sum_assignment(w.max() - w)
max_cells = list(zip(row_ind, col_ind))
max_cells.sort(key=lambda tup: tup[1])
maximum_values = np.array([w[c[0], c[1]] for c in max_cells])
gt_groups_sizes = np.sum(w, axis=0)
pred_groups_sizes = np.sum(w, axis=1)
if show_confusion_matrix:
logger.info('Confusion Matrix \n %r' % w)
logger.info('Maximum Cells %r' % max_cells)
logger.info('Maximum Values %r' % maximum_values)
# print("Max values %r" % maximum_values)
# print("group sizes %r" % gt_groups_sizes)
# print("Predicted cls sizes %r" % pred_groups_sizes)
return maximum_values, gt_groups_sizes, pred_groups_sizes
out_file.write('\n')
with open(out_file_parsable + ('.%s' % quality if len(quality) > 0 else ''), 'w') as out_file:
out_file.write('\n'.join(
map(str, chain.from_iterable(map(lambda l: l[:topk] if topk > 0 else l, per_var_predictions.values())))))
return out_filepath_with_type
if __name__ == '__main__':
vos_executer = EndPointKGQueryInterface('http://halimede:8890/sparql',
['http://yago-expr.org', 'http://yago-expr.org.types'])
descriptions = load_from_file(
'/scratch/GW/pool0/gadelrab/ExDEC/results/baseline_data/imdb/TransE/ADAPT_PROGRESSIVE/ASSIGNMENTS_SUBGRAPH/x_coverage_Kmeans_direct_h3_correlation/run_21022020_170650/steps/itr_0/explanations.txt.parsable')
logger.info("Descriptions #: %i", (len(descriptions)))
ded = SparqlBasedDeductionEngine(vos_executer)
per_var_predictions = ded.infer(descriptions)
# print(per_var_predictions)
# print(per_var_predictions.items()[:10])
logger.info("Total variables with predictions subjects: %i", len(per_var_predictions))
# labelsGraph = Graph(store='SPARQLStore', identifier='http://yago-labels-encoded.org')
# labelsGraph.open('http://badr:8890/sparql')
#
# gt_facts = map(
# lambda t: Prediction((str(t[0]), str(t[1]), str(t[2])),
def restore_model(model_name_path=None,
module_name="ampligraph.latent_features"):
"""Restore a saved model from disk.
See also :meth:`save_model`.
Parameters
----------
model_name_path: string
The name of saved model to be restored. If not specified,
the library will try to find the default model in the working directory.
Returns
-------
model: EmbeddingModel
the neural knowledge graph embedding model restored from disk.
"""
if model_name_path is None:
logger.warning("There is no model name specified. \
We will try to lookup \
the latest default saved model...")
default_models = glob.glob("*.model.pkl")
if len(default_models) == 0:
raise Exception("No default model found. Please specify \
model_name_path...")
else:
model_name_path = default_models[len(default_models) - 1]
logger.info("Will will load the model: {0} in your \
current dir...".format(model_name_path))
model = None
logger.info('Will load model {}.'.format(model_name_path))
try:
with open(model_name_path, 'rb') as fr:
restored_obj = pickle.load(fr)
logger.debug('Restoring model ...')
module = importlib.import_module(module_name)
class_ = getattr(module,
restored_obj['class_name'].replace('Continue', ''))
model = class_(**restored_obj['hyperparams'])
model.is_fitted = restored_obj['is_fitted']
model.ent_to_idx = restored_obj['ent_to_idx']
model.rel_to_idx = restored_obj['rel_to_idx']
try:
model.is_calibrated = restored_obj['is_calibrated']
except KeyError:
model.is_calibrated = False
model.restore_model_params(restored_obj)
except pickle.UnpicklingError as e:
msg = 'Error unpickling model {} : {}.'.format(model_name_path, e)
logger.debug(msg)
raise Exception(msg)
except (IOError, FileNotFoundError):
msg = 'No model found: {}.'.format(model_name_path)
logger.debug(msg)
raise FileNotFoundError(msg)
return model
def fit(self,
X,
early_stopping=False,
early_stopping_params={},
continue_training=False):
"""Train an EmbeddingModel (with optional early stopping).
The model is trained on a training set X using the training protocol
described in :cite:`trouillon2016complex`.
Parameters
----------
X : ndarray (shape [n, 3]) or object of AmpligraphDatasetAdapter
Numpy array of training triples OR handle of Dataset adapter which would help retrieve data.
early_stopping: bool
Flag to enable early stopping (default:``False``)
early_stopping_params: dictionary
Dictionary of hyperparameters for the early stopping heuristics.
The following string keys are supported:
- **'x_valid'**: ndarray (shape [n, 3]) or object of AmpligraphDatasetAdapter :
Numpy array of validation triples OR handle of Dataset adapter which
would help retrieve data.
- **'criteria'**: string : criteria for early stopping 'hits10', 'hits3', 'hits1' or 'mrr'(default).
- **'x_filter'**: ndarray, shape [n, 3] : Positive triples to use as filter if a 'filtered' early
stopping criteria is desired (i.e. filtered-MRR if 'criteria':'mrr').
Note this will affect training time (no filter by default).
If the filter has already been set in the adapter, pass True
- **'burn_in'**: int : Number of epochs to pass before kicking in early stopping (default: 100).
- **check_interval'**: int : Early stopping interval after burn-in (default:10).
- **'stop_interval'**: int : Stop if criteria is performing worse over n consecutive checks (default: 3)
- **'corruption_entities'**: List of entities to be used for corruptions. If 'all',
it uses all entities (default: 'all')
- **'corrupt_side'**: Specifies which side to corrupt. 's', 'o', 's+o' (default)
Example: ``early_stopping_params={x_valid=X['valid'], 'criteria': 'mrr'}``
"""
self.train_dataset_handle = None
# try-except block is mainly to handle clean up in case of exception or manual stop in jupyter notebook
# TODO change 0: Update the mapping if there are new entities.
if continue_training:
self.update_mapping(X)
try:
if isinstance(X, np.ndarray):
# Adapt the numpy data in the internal format - to generalize
self.train_dataset_handle = NumpyDatasetAdapter()
self.train_dataset_handle.set_data(X, "train")
elif isinstance(X, AmpligraphDatasetAdapter):
self.train_dataset_handle = X
else:
msg = 'Invalid type for input X. Expected ndarray/AmpligraphDataset object, got {}'.format(
type(X))
logger.error(msg)
raise ValueError(msg)
# create internal IDs mappings
# TODO Change 1: fist change to reuse the existing mappings rel_to_idx and ent_to_idx
if not continue_training:
self.rel_to_idx, self.ent_to_idx = self.train_dataset_handle.generate_mappings(
)
else:
self.train_dataset_handle.use_mappings(self.rel_to_idx,
self.ent_to_idx)
prefetch_batches = 1
if len(self.ent_to_idx) > ENTITY_THRESHOLD:
self.dealing_with_large_graphs = True
logger.warning(
'Your graph has a large number of distinct entities. '
'Found {} distinct entities'.format(len(self.ent_to_idx)))
logger.warning(
'Changing the variable initialization strategy.')
logger.warning(
'Changing the strategy to use lazy loading of variables...'
)
if early_stopping:
raise Exception(
'Early stopping not supported for large graphs')
if not isinstance(self.optimizer, SGDOptimizer):
raise Exception(
"This mode works well only with SGD optimizer with decay (read docs for details).\
Kindly change the optimizer and restart the experiment")
if self.dealing_with_large_graphs:
prefetch_batches = 0
# CPU matrix of embeddings
# TODO Change 2.1: do not intialize if continue training
if not continue_training:
self.ent_emb_cpu = self.initializer.get_np_initializer(
len(self.ent_to_idx), self.internal_k)
self.train_dataset_handle.map_data()
# This is useful when we re-fit the same model (e.g. retraining in model selection)
if self.is_fitted:
tf.reset_default_graph()
self.rnd = check_random_state(self.seed)
tf.random.set_random_seed(self.seed)
self.sess_train = tf.Session(config=self.tf_config)
# change 2.2 : Do not change batch size with new training data, just use the old (for large KGs)
# if not continue_training:
batch_size = int(
np.ceil(
self.train_dataset_handle.get_size("train") /
self.batches_count))
# else:
# batch_size = self.batch_size
logger.info("Batch Size: %i" % batch_size)
# dataset = tf.data.Dataset.from_tensor_slices(X).repeat().batch(batch_size).prefetch(2)
if len(self.ent_to_idx) > ENTITY_THRESHOLD:
logger.warning(
'Only {} embeddings would be loaded in memory per batch...'
.format(batch_size * 2))
self.batch_size = batch_size
# TODO change 3: load model from trained params if continue instead of re_initialize the ent_emb and rel_emb
if not continue_training:
self._initialize_parameters()
else:
self._load_model_from_trained_params()
dataset = tf.data.Dataset.from_generator(
self._training_data_generator,
output_types=(tf.int32, tf.int32, tf.float32),
output_shapes=((None, 3), (None, 1), (None, self.internal_k)))
dataset = dataset.repeat().prefetch(prefetch_batches)
dataset_iterator = tf.data.make_one_shot_iterator(dataset)
# init tf graph/dataflow for training
# init variables (model parameters to be learned - i.e. the embeddings)
if self.loss.get_state('require_same_size_pos_neg'):
batch_size = batch_size * self.eta
loss = self._get_model_loss(dataset_iterator)
train = self.optimizer.minimize(loss)
# Entity embeddings normalization
normalize_ent_emb_op = self.ent_emb.assign(
tf.clip_by_norm(self.ent_emb, clip_norm=1, axes=1))
self.early_stopping_params = early_stopping_params
# early stopping
if early_stopping:
self._initialize_early_stopping()
self.sess_train.run(tf.tables_initializer())
self.sess_train.run(tf.global_variables_initializer())
try:
self.sess_train.run(self.set_training_true)
except AttributeError:
pass
normalize_rel_emb_op = self.rel_emb.assign(
tf.clip_by_norm(self.rel_emb, clip_norm=1, axes=1))
if self.embedding_model_params.get(
'normalize_ent_emb',
constants.DEFAULT_NORMALIZE_EMBEDDINGS):
self.sess_train.run(normalize_rel_emb_op)
self.sess_train.run(normalize_ent_emb_op)
epoch_iterator_with_progress = tqdm(range(1, self.epochs + 1),
disable=(not self.verbose),
unit='epoch')
# print("before epochs!")
# print(self.sess_train.run(self.ent_emb))
# print(self.sess_train.run(self.rel_emb))
for epoch in epoch_iterator_with_progress:
losses = []
for batch in range(1, self.batches_count + 1):
feed_dict = {}
self.optimizer.update_feed_dict(feed_dict, batch, epoch)
if self.dealing_with_large_graphs:
loss_batch, unique_entities, _ = self.sess_train.run(
[loss, self.unique_entities, train],
feed_dict=feed_dict)
self.ent_emb_cpu[np.squeeze(unique_entities), :] = \
self.sess_train.run(self.ent_emb)[:unique_entities.shape[0], :]
else:
loss_batch, _ = self.sess_train.run(
[loss, train], feed_dict=feed_dict)
if np.isnan(loss_batch) or np.isinf(loss_batch):
msg = 'Loss is {}. Please change the hyperparameters.'.format(
loss_batch)
logger.error(msg)
raise ValueError(msg)
losses.append(loss_batch)
if self.embedding_model_params.get(
'normalize_ent_emb',
constants.DEFAULT_NORMALIZE_EMBEDDINGS):
self.sess_train.run(normalize_ent_emb_op)
if self.verbose:
msg = 'Average Loss: {:10f}'.format(
sum(losses) / (batch_size * self.batches_count))
if early_stopping and self.early_stopping_best_value is not None:
msg += ' — Best validation ({}): {:5f}'.format(
self.early_stopping_criteria,
self.early_stopping_best_value)
logger.debug(msg)
epoch_iterator_with_progress.set_description(msg)
if early_stopping:
try:
self.sess_train.run(self.set_training_false)
except AttributeError:
pass
if self._perform_early_stopping_test(epoch):
self._end_training()
return
try:
self.sess_train.run(self.set_training_true)
except AttributeError:
pass
self._save_trained_params()
self._end_training()
except BaseException as e:
self._end_training()
raise e
def update_embedding(self):
logger.info("Start Updating embedding stage")
self.embedding.adapt(self.current_itr.augmentation_triples)
logger.info("Done Updating embedding stage")
def end_process(self):
super().end_process()
logger.info("Clean Explanations Temp Graphs")
self.clusters_explainer.clear_data()
logger.info("Done Clean Explanations Temp Graphs!")
