Download annotations/annotation_39/BASRec/GRU4Rec/src/utils.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 7.37 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_39/BASRec/GRU4Rec/src/utils.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_39/BASRec/GRU4Rec/src/utils.py
-
curl -L -o utils.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_39/BASRec/GRU4Rec/src/utils.py
7.37 kB
| # -*- 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 | |