import numpy as np
from tqdm import tqdm
from elliot.utils.write import store_recommendation
[docs]class RecMixin(object):
[docs] def train(self):
if self._restore:
return self.restore_weights()
best_metric_value = 0
for it in range(self._num_iters):
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:.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")
[docs] def get_recommendations(self, k: int = 100):
predictions_top_k = {}
for index, offset in enumerate(range(0, self._num_users, self._batch_size)):
offset_stop = min(offset + self._batch_size, self._num_users)
predictions = self._model.predict(self._data.sp_i_train[offset:offset_stop].toarray())
v, i = self._model.get_top_k(predictions, self.get_train_mask(offset, offset_stop), k=k)
items_ratings_pair = [list(zip(map(self._data.private_items.get, u_list[0]), u_list[1]))
for u_list in list(zip(i.numpy(), v.numpy()))]
predictions_top_k.update(dict(zip(map(self._data.private_users.get,
range(offset, offset_stop)), items_ratings_pair)))
return predictions_top_k
[docs] def restore_weights(self):
try:
self._model.load_weights(self._saving_filepath)
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:
raise Exception(f"Error in model restoring operation! {ex}")
return False
[docs] def get_train_mask(self, start, stop):
return np.where((self._data.sp_i_train[range(start, stop)].toarray() == 0), True, False)
[docs] def get_loss(self):
return -max([r[self._validation_k]["val_results"][self._validation_metric] for r in self._results])
[docs] def get_params(self):
return self._params.__dict__
[docs] def get_results(self):
val_max = np.argmax([r[self._validation_k]["val_results"][self._validation_metric] for r in self._results])
return self._results[val_max]