def train(self):
if self._restore:
return self.restore_weights()
self._model.initialize()
print(f"Transactions: {self._data.transactions}")
best_metric_value = 0
print("Computing recommendations..")
recs = self.get_recommendations(
self.evaluator.get_needed_recommendations())
result_dict = self.evaluator.eval(recs)
self._results.append(result_dict)
print(f'Finished')
if self._results[-1][self._validation_k]["val_results"][
self._validation_metric] > best_metric_value:
print("******************************************")
if self._save_weights:
with open(self._saving_filepath, "wb") as f:
pickle.dump(self._model.get_model_state(), f)
if self._save_recs:
store_recommendation(
recs,
self._config.path_output_rec_result + f"{self.name}.tsv")
def train(self):
if self._restore:
return self.restore_weights()
print(f"Transactions: {self._data.transactions}")
best_metric_value = -np.inf
for it in range(self._epochs):
print(f"\n********** Iteration: {it + 1}")
self._iteration = it
self.train_step()
if not (it + 1) % self._validation_rate:
recs = self.get_recommendations(
self.evaluator.get_needed_recommendations())
result_dict = self.evaluator.eval(recs)
self._results.append(result_dict)
if self._results[-1][self._validation_k]["val_results"][
self._validation_metric] > best_metric_value:
print("******************************************")
best_metric_value = self._results[-1][self._validation_k][
"val_results"][self._validation_metric]
if self._save_weights:
with open(self._saving_filepath, "wb") as f:
pickle.dump(self._model.get_model_state(), f)
if self._save_recs:
store_recommendation(
recs, self._config.path_output_rec_result +
f"{self.name}-it:{it + 1}.tsv")
def train(self):
if self._restore:
is_restored = self.restore_weights()
if is_restored:
return True
else:
print('This Model will start the training!')
best_metric_value = 0
loss = 0
steps = 0
it = 0
early_stopping = 5
with tqdm(total=int(self._data.transactions // self._batch_size),
disable=not self._verbose) as t:
for batch in self._next_batch:
steps += 1
loss += self._model.train_step(batch)
t.set_postfix({'loss': f'{loss.numpy() / steps:.5f}'})
t.update()
# epoch is over
if steps == self._data.transactions // self._batch_size:
t.reset()
if not (it + 1) % self._validation_rate:
recs = self.get_recommendations(
self.evaluator.get_needed_recommendations())
result_dict = self.evaluator.eval(recs)
self._results.append(result_dict)
self.logger.info(
f'Epoch {(it + 1)}/{self._epochs} loss {loss / steps:.3f}'
)
if self._results[-1][self._validation_k]["val_results"][
self._validation_metric] > best_metric_value:
best_metric_value = self._results[-1][
self._validation_k]["val_results"][
self._validation_metric]
early_stopping = 5
if self._save_weights:
self._model.save_weights(self._saving_filepath)
if self._save_recs:
# store_recommendation(recs,
# self._config.path_output_rec_result + f"{self.name}-it:{it + 1}.tsv")
store_recommendation(
recs, self._config.path_output_rec_result +
f"{self.name}.tsv")
else:
early_stopping -= 1
if early_stopping == 0:
print(
'Reached Early Stopping Condition at Epoch {0}\n\tEXIT'
.format(it + 1))
break
it += 1
steps = 0
loss = 0
def restore_weights(self):
try:
self._model.load_weights(self._saving_filepath)
print(f"Model correctly Restored")
try:
print('Try to restore rec lists')
recs = self.restore_recommendation(
path=self._config.path_output_rec_result +
f"{self.name}.tsv")
except Exception as error:
print(f'** Error in Try to restore rec lists\n\t{error}\n')
print('Evaluate rec lists')
recs = self.get_recommendations(
self.evaluator.get_needed_recommendations())
result_dict = self.evaluator.eval(recs)
self._results.append(result_dict)
print("******************************************")
if self._save_recs:
store_recommendation(
recs,
self._config.path_output_rec_result + f"{self.name}.tsv")
return True
except Exception as ex:
print(f"Error in model restoring operation! {ex}")
return False
def train(self):
recs = self.get_recommendations(self.evaluator.get_needed_recommendations())
result_dict = self.evaluator.eval(recs)
self._results.append(result_dict)
if self._save_recs:
store_recommendation(recs, self._config.path_output_rec_result + f"{self.name}.tsv")
def train(self):
if self._restore:
return self.restore_weights()
best_metric_value = 0
for it in range(self._epochs):
dis_loss, gen_loss = 0, 0
steps = 0
with tqdm(total=int(self._data.transactions // self._batch_size), disable=not self._verbose) as t:
for batch in self._sampler.step(self._data.transactions, self._batch_size):
steps += 1
update_dis_loss, update_gen_loss = self._model.train_step(batch)
dis_loss += update_dis_loss
gen_loss += update_gen_loss
t.set_postfix({'Dis loss': f'{dis_loss.numpy() / steps:.5f}', 'Gen loss': f'{gen_loss.numpy() / steps:.5f}'})
t.update()
if not (it + 1) % self._validation_rate:
recs = self.get_recommendations(self.evaluator.get_needed_recommendations())
result_dict = self.evaluator.eval(recs)
self._results.append(result_dict)
print(f'Epoch {(it + 1)}/{self._epochs} Dis loss: {dis_loss.numpy() / steps:.5f}, Gen loss: {gen_loss.numpy() / steps:.5f}')
if self._results[-1][self._validation_k]["val_results"][self._validation_metric] > best_metric_value:
print("******************************************")
best_metric_value = self._results[-1][self._validation_k]["val_results"][self._validation_metric]
if self._save_weights:
self._model.save_weights(self._saving_filepath)
if self._save_recs:
store_recommendation(recs, self._config.path_output_rec_result + f"{self.name}-it:{it + 1}.tsv")
def evaluate(self, it = None, loss = 0):
if (it is None) or (not (it + 1) % self._validation_rate):
recs = self.get_recommendations(self.evaluator.get_needed_recommendations())
result_dict = self.evaluator.eval(recs)
self._losses.append(loss)
self._results.append(result_dict)
if it is not None:
self.logger.info(f'Epoch {(it + 1)}/{self._epochs} loss {loss/(it + 1):.5f}')
else:
self.logger.info(f'Finished')
if (len(self._results) - 1) == self.get_best_arg():
self.logger.info("******************************************")
self.best_metric_value = self._results[-1][self._validation_k]["val_results"][self._validation_metric]
if self._save_weights:
if hasattr(self, "_model"):
self._model.save_weights(self._saving_filepath)
else:
self.logger.warning("Saving weights FAILED. No model to save.")
if self._save_recs:
if it is not None:
store_recommendation(recs[1], self._config.path_output_rec_result + f"{self.name}-it:{it + 1}.tsv")
else:
store_recommendation(recs[1], self._config.path_output_rec_result + f"{self.name}.tsv")
def train(self):
if self._restore:
return self.restore_weights()
best_metric_value = 0
for it in range(1, self._epochs+1):
user_adv_train = (self._epochs - it) < self._adversarial_epochs
loss = 0
steps = 0
with tqdm(total=int(self._data.transactions // self._batch_size), disable=not self._verbose) as t:
for batch in self._sampler.step(self._data.transactions, self._batch_size):
steps += 1
loss += self._model.train_step(batch, user_adv_train)
# t.set_postfix({'loss': f'{loss.numpy() / steps:.5f}'})
t.set_postfix({'(APR)-loss' if user_adv_train else '(BPR)-loss': f'{loss.numpy() / steps:.5f}'})
t.update()
if not (it + 1) % self._validation_rate:
recs = self.get_recommendations(self.evaluator.get_needed_recommendations())
result_dict = self.evaluator.eval(recs)
self._results.append(result_dict)
print(f'Epoch {(it + 1)}/{self._epochs} loss {loss / steps:.3f}')
if self._results[-1][self._validation_k]["val_results"][self._validation_metric] > best_metric_value:
print("******************************************")
best_metric_value = self._results[-1][self._validation_k]["val_results"][self._validation_metric]
if self._save_weights:
self._model.save_weights(self._saving_filepath)
if self._save_recs:
store_recommendation(recs, self._config.path_output_rec_result + f"{self.name}-it:{it + 1}.tsv")
def train(self):
if self._restore:
return self.restore_weights()
best_metric_value = 0
for it in range(self._epochs):
loss = 0
steps = 0
with tqdm(total=int(self._data.transactions * 2 //
self._batch_size),
disable=not self._verbose) as t:
# update items and fix users
for batch in self._sampler.step(self._data.transactions,
self._batch_size):
steps += 1
self._model.set_update_user(False)
loss += self._model.train_step(batch)
t.set_postfix({'loss': f'{loss.numpy() / steps:.5f}'})
t.update()
# update users and fix items
for batch in self._sampler.step(self._data.transactions,
self._batch_size):
steps += 1
self._model.set_update_user(True)
loss += self._model.train_step(batch)
t.set_postfix({'loss': f'{loss.numpy() / steps:.5f}'})
t.update()
if not (it + 1) % self._validation_rate:
recs = self.get_recommendations(
self.evaluator.get_needed_recommendations())
result_dict = self.evaluator.eval(recs)
self._results.append(result_dict)
print(f'Epoch {(it + 1)}/{self._epochs} loss {loss/steps:.5f}')
if self._results[-1][self._validation_k]["val_results"][
self._validation_metric] > best_metric_value:
print("******************************************")
best_metric_value = self._results[-1][self._validation_k][
"val_results"][self._validation_metric]
if self._save_weights:
self._model.save_weights(self._saving_filepath)
if self._save_recs:
store_recommendation(
recs, self._config.path_output_rec_result +
f"{self.name}-it:{it + 1}.tsv")
def train(self):
if self._restore:
return self.restore_weights()
self._model.train(self._verbose)
recs = self.get_recommendations(self.evaluator.get_needed_recommendations())
result_dict = self.evaluator.eval(recs)
self._results.append(result_dict)
print("******************************************")
if self._save_weights:
with open(self._saving_filepath, "wb") as f:
pickle.dump(self._model.get_model_state(), f)
if self._save_recs:
store_recommendation(recs, self._config.path_output_rec_result + f"{self.name}.tsv")
def train(self):
if self._restore:
return self.restore_weights()
best_metric_value = 0
self._update_count = 0
for it in range(self._epochs):
loss = 0
steps = 0
with tqdm(total=int(self._num_users // self._batch_size),
disable=not self._verbose) as t:
for batch in self._sampler.step(self._num_users,
self._batch_size):
steps += 1
if self._total_anneal_steps > 0:
anneal = min(
self._anneal_cap,
1. * self._update_count / self._total_anneal_steps)
else:
anneal = self._anneal_cap
loss += self._model.train_step(batch, anneal)
t.set_postfix({'loss': f'{loss.numpy()/steps:.5f}'})
t.update()
self._update_count += 1
if not (it + 1) % self._validation_rate:
recs = self.get_recommendations(
self.evaluator.get_needed_recommendations())
result_dict = self.evaluator.eval(recs)
self._results.append(result_dict)
print(f'Epoch {(it + 1)}/{self._epochs} loss {loss/steps:.5f}')
if self._results[-1][self._validation_k]["val_results"][
self._validation_metric] > best_metric_value:
print("******************************************")
best_metric_value = self._results[-1][self._validation_k][
"val_results"][self._validation_metric]
if self._save_weights:
self._model.save_weights(self._saving_filepath)
if self._save_recs:
store_recommendation(
recs, self._config.path_output_rec_result +
f"{self.name}-it:{it + 1}.tsv")
def train(self):
if self._restore:
return self.restore_weights()
best_metric_value = 0
early_stopping = 5
for it in range(self._epochs):
loss = 0
steps = 0
with tqdm(total=int(self._data.transactions // self._batch_size),
disable=not self._verbose) as t:
for batch in self._sampler.step(self._data.transactions,
self._batch_size):
steps += 1
loss += self._model.train_step(batch)
t.set_postfix({'loss': f'{loss.numpy() / steps:.5f}'})
t.update()
if not (it + 1) % self._validation_rate:
recs = self.get_recommendations(
self.evaluator.get_needed_recommendations())
result_dict = self.evaluator.eval(recs)
self._results.append(result_dict)
print(
f'Epoch {(it + 1)}/{self._epochs} loss {loss / steps:.3f}'
)
if self._results[-1][self._validation_k]["val_results"][
self._validation_metric] > best_metric_value:
print("******************************************")
best_metric_value = self._results[-1][self._validation_k][
"val_results"][self._validation_metric]
early_stopping = 5
if self._save_weights:
self._model.save_weights(self._saving_filepath)
if self._save_recs:
store_recommendation(
recs, self._config.path_output_rec_result +
f"{self.name}-it:{it + 1}.tsv")
else:
early_stopping -= 1
if early_stopping == 0:
print(
'Reached Early Stopping Condition at Epoch {0}\n\tEXIT'
.format(it + 1))
break
def train(self):
if self._restore:
return self.restore_weights()
best_metric_value = 0
loss = 0
steps = 0
it = 0
with tqdm(total=int(self._data.transactions // self._batch_size),
disable=not self._verbose) as t:
for batch in self._next_batch:
steps += 1
loss += self._model.train_step(batch)
t.set_postfix({'loss': f'{loss.numpy() / steps:.5f}'})
t.update()
# epoch is over
if steps == self._data.transactions // self._batch_size:
t.reset()
if not (it + 1) % self._validation_rate:
recs = self.get_recommendations(
self.evaluator.get_needed_recommendations())
result_dict = self.evaluator.eval(recs)
self._results.append(result_dict)
self.logger.info(
f'Epoch {(it + 1)}/{self._epochs} loss {loss / steps:.3f}'
)
if self._results[-1][self._validation_k]["val_results"][
self._validation_metric] > best_metric_value:
best_metric_value = self._results[-1][
self._validation_k]["val_results"][
self._validation_metric]
if self._save_weights:
self._model.save_weights(self._saving_filepath)
if self._save_recs:
store_recommendation(
recs, self._config.path_output_rec_result +
f"{self.name}-it:{it + 1}.tsv")
it += 1
steps = 0
loss = 0
def restore_weights(self):
try:
with open(self._saving_filepath, "rb") as f:
self._model.set_model_state(pickle.load(f))
print(f"Model correctly Restored")
recs = self.get_recommendations(self.evaluator.get_needed_recommendations())
result_dict = self.evaluator.eval(recs)
self._results.append(result_dict)
print("******************************************")
if self._save_recs:
store_recommendation(recs, self._config.path_output_rec_result + f"{self.name}.tsv")
return True
except Exception as ex:
print(f"Error in model restoring operation! {ex}")
return False
def train(self):
if self._restore:
return self.restore_weights()
best_metric_value = 0
for it in range(self._epochs):
loss = 0
steps = 0
with tqdm(total=int(self._data.transactions // self._batch_size),
disable=not self._verbose) as t:
for batch in self._sampler.step(self._data.transactions,
self._batch_size):
steps += 1
loss += self._model.train_step(batch)
t.set_postfix({'loss': f'{loss / steps:.5f}'})
t.update()
if not (it + 1) % self._validation_rate:
print("Computing recommendations..")
recs = self.get_recommendations(
self.evaluator.get_needed_recommendations())
result_dict = self.evaluator.eval(recs)
self._results.append(result_dict)
print(f'Finished')
print(
f'Epoch {(it + 1)}/{self._epochs} loss {loss / steps:.3f}'
)
if self._results[-1][self._validation_k]["val_results"][
self._validation_metric] > best_metric_value:
print("******************************************")
best_metric_value = self._results[-1][self._validation_k][
"val_results"][self._validation_metric]
if self._save_weights:
with open(self._saving_filepath, "wb") as f:
pickle.dump(self._model.get_model_state(), f)
if self._save_recs:
store_recommendation(
recs, self._config.path_output_rec_result +
f"{self.name}-it:{it + 1}.tsv")
