# -*- coding: utf-8 -*- import os import math import torch import random import numpy as np from scipy.sparse import csr_matrix def set_seed(seed): random.seed(seed) os.environ['PYTHONHASHSEED'] = str(seed) np.random.seed(seed) torch.manual_seed(seed) torch.cuda.manual_seed(seed) torch.cuda.manual_seed_all(seed) # some cudnn methods can be random even after fixing the seed # unless you tell it to be deterministic torch.backends.cudnn.deterministic = True def check_path(path): if not os.path.exists(path): os.makedirs(path) print(f'{path} created') def neg_sample(item_set, item_size): item = random.randint(1, item_size - 1) while item in item_set: item = random.randint(1, item_size - 1) return item class EarlyStopping: """Early stops the training if validation loss doesn't improve after a given patience.""" def __init__(self, checkpoint_path, patience=7, verbose=False, delta=0): """ Args: patience (int): How long to wait after last time validation loss improved. Default: 7 verbose (bool): If True, prints a message for each validation loss improvement. Default: False delta (float): Minimum change in the monitored quantity to qualify as an improvement. Default: 0 """ self.checkpoint_path = checkpoint_path self.patience = patience self.verbose = verbose self.counter = 0 self.best_score = None self.early_stop = False self.delta = delta def compare(self, score): for i in range(len(score)): if score[i] > self.best_score[i] + self.delta: return False return True def __call__(self, score, model): # score HIT@10 NDCG@10 if self.best_score is None: self.best_score = score self.score_min = np.array([0] * len(score)) self.save_checkpoint(score, model) elif self.compare(score): self.counter += 1 print(f'EarlyStopping counter: {self.counter} out of {self.patience}') if self.counter >= self.patience: self.early_stop = True else: self.best_score = score self.save_checkpoint(score, model) self.counter = 0 def save_checkpoint(self, score, model): """ Saves model when validation loss decrease. """ if self.verbose: print(f'Validation score increased. Saving model ...') torch.save(model.state_dict(), self.checkpoint_path) self.score_min = score def generate_rating_matrix_valid(user_seq, num_users, num_items): # three lists are used to construct sparse matrix row = [] col = [] data = [] for user_id, item_list in enumerate(user_seq): for item in item_list[:-2]: # row.append(user_id) col.append(item) data.append(1) row = np.array(row) col = np.array(col) data = np.array(data) rating_matrix = csr_matrix((data, (row, col)), shape=(num_users, num_items)) return rating_matrix def generate_rating_matrix_test(user_seq, num_users, num_items): # three lists are used to construct sparse matrix row = [] col = [] data = [] for user_id, item_list in enumerate(user_seq): for item in item_list[:-1]: # row.append(user_id) col.append(item) data.append(1) row = np.array(row) col = np.array(col) data = np.array(data) rating_matrix = csr_matrix((data, (row, col)), shape=(num_users, num_items)) return rating_matrix def get_user_seqs(data_file): lines = open(data_file).readlines() user_seqs = [] item_set = set() for line in lines: user, items = line.strip().split(' ', 1) items = items.split(' ') items = [int(item) for item in items] user_seqs.append(items) item_set = item_set | set(items) max_item = max(item_set) num_users = len(lines) num_items = max_item + 2 valid_rating_matrix = generate_rating_matrix_valid(user_seqs, num_users, num_items) test_rating_matrix = generate_rating_matrix_test(user_seqs, num_users, num_items) return user_seqs, max_item, valid_rating_matrix, test_rating_matrix def get_metric(pred_list, topk=10): NDCG = 0.0 HIT = 0.0 MRR = 0.0 # [batch] the answer's rank for rank in pred_list: MRR += 1.0 / (rank + 1.0) if rank < topk: NDCG += 1.0 / np.log2(rank + 2.0) HIT += 1.0 return HIT / len(pred_list), NDCG / len(pred_list), MRR / len(pred_list) def recall_at_k(actual, predicted, topk): sum_recall = 0.0 num_users = len(predicted) true_users = 0 for i in range(num_users): act_set = set(actual[i]) pred_set = set(predicted[i][:topk]) if len(act_set) != 0: sum_recall += len(act_set & pred_set) / float(len(act_set)) true_users += 1 return sum_recall / true_users def apk(actual, predicted, k=10): """ Computes the average precision at k. This function computes the average precision at k between two lists of items. Parameters ---------- actual : list A list of elements that are to be predicted (order doesn't matter) predicted : list A list of predicted elements (order does matter) k : int, optional The maximum number of predicted elements Returns ------- score : double The average precision at k over the input lists """ if len(predicted) > k: predicted = predicted[:k] score = 0.0 num_hits = 0.0 for i, p in enumerate(predicted): if p in actual and p not in predicted[:i]: num_hits += 1.0 score += num_hits / (i + 1.0) if not actual: return 0.0 return score / min(len(actual), k) def mapk(actual, predicted, k=10): """ Computes the mean average precision at k. This function computes the mean average prescision at k between two lists of lists of items. Parameters ---------- actual : list A list of lists of elements that are to be predicted (order doesn't matter in the lists) predicted : list A list of lists of predicted elements (order matters in the lists) k : int, optional The maximum number of predicted elements Returns ------- score : double The mean average precision at k over the input lists """ return np.mean([apk(a, p, k) for a, p in zip(actual, predicted)]) def ndcg_k(actual, predicted, topk): res = 0 for user_id in range(len(actual)): k = min(topk, len(actual[user_id])) idcg = idcg_k(k) dcg_k = sum([int(predicted[user_id][j] in set(actual[user_id])) / math.log(j + 2, 2) for j in range(topk)]) res += dcg_k / idcg return res / float(len(actual)) # Calculates the ideal discounted cumulative gain at k def idcg_k(k): res = sum([1.0 / math.log(i + 2, 2) for i in range(k)]) if not res: return 1.0 else: return res