Download annotations/annotation_34/ELCRec/src/utils.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 7.31 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_34/ELCRec/src/utils.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_34/ELCRec/src/utils.py
-
curl -L -o utils.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_34/ELCRec/src/utils.py
7.31 kB
| import os | |
| import math | |
| import json | |
| 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) | |
| torch.backends.cudnn.deterministic = True | |
| def nCr(n, r): | |
| f = math.factorial | |
| return f(n) // f(r) // f(n - r) | |
| def check_path(path): | |
| if not os.path.exists(path): | |
| os.makedirs(path) | |
| print(f"{path} created") | |
| class EarlyStopping: | |
| def __init__(self, checkpoint_path, patience=7, verbose=False, delta=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): | |
| 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 | |
| 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): | |
| torch.save(model.state_dict(), self.checkpoint_path) | |
| self.score_min = score | |
| 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 | |
| def kmax_pooling(x, dim, k): | |
| index = x.topk(k, dim=dim)[1].sort(dim=dim)[0] | |
| return x.gather(dim, index).squeeze(dim) | |
| def avg_pooling(x, dim): | |
| return x.sum(dim=dim) / x.size(dim) | |
| def generate_rating_matrix_valid(user_seq, num_users, num_items): | |
| 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): | |
| 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_seq = [] | |
| item_set = set() | |
| for line in lines: | |
| try: | |
| user, items = line.strip().split(" ", 1) | |
| except: | |
| continue | |
| items = items.split(" ") | |
| items = [int(item) for item in items] | |
| user_seq.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_seq, num_users, num_items) | |
| test_rating_matrix = generate_rating_matrix_test(user_seq, num_users, num_items) | |
| return user_seq, max_item, valid_rating_matrix, test_rating_matrix | |
| def get_user_seqs_long(data_file): | |
| lines = open(data_file).readlines() | |
| user_seq = [] | |
| long_sequence = [] | |
| item_set = set() | |
| for line in lines: | |
| user, items = line.strip().split(" ", 1) | |
| items = items.split(" ") | |
| items = [int(item) for item in items] | |
| long_sequence.extend(items) | |
| user_seq.append(items) | |
| item_set = item_set | set(items) | |
| max_item = max(item_set) | |
| return user_seq, max_item, long_sequence | |
| def get_user_seqs_and_sample(data_file, sample_file): | |
| lines = open(data_file).readlines() | |
| user_seq = [] | |
| item_set = set() | |
| for line in lines: | |
| user, items = line.strip().split(" ", 1) | |
| items = items.split(" ") | |
| items = [int(item) for item in items] | |
| user_seq.append(items) | |
| item_set = item_set | set(items) | |
| max_item = max(item_set) | |
| lines = open(sample_file).readlines() | |
| sample_seq = [] | |
| for line in lines: | |
| user, items = line.strip().split(" ", 1) | |
| items = items.split(" ") | |
| items = [int(item) for item in items] | |
| sample_seq.append(items) | |
| assert len(user_seq) == len(sample_seq) | |
| return user_seq, max_item, sample_seq | |
| def get_item2attribute_json(data_file): | |
| item2attribute = json.loads(open(data_file).readline()) | |
| attribute_set = set() | |
| for item, attributes in item2attribute.items(): | |
| attribute_set = attribute_set | set(attributes) | |
| attribute_size = max(attribute_set) # 331 | |
| return item2attribute, attribute_size | |
| def get_metric(pred_list, topk=10): | |
| NDCG = 0.0 | |
| HIT = 0.0 | |
| MRR = 0.0 | |
| 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 precision_at_k_per_sample(actual, predicted, topk): | |
| num_hits = 0 | |
| for place in predicted: | |
| if place in actual: | |
| num_hits += 1 | |
| return num_hits / (topk + 0.0) | |
| def precision_at_k(actual, predicted, topk): | |
| sum_precision = 0.0 | |
| num_users = len(predicted) | |
| for i in range(num_users): | |
| act_set = set(actual[i]) | |
| pred_set = set(predicted[i][:topk]) | |
| sum_precision += len(act_set & pred_set) / float(topk) | |
| return sum_precision / num_users | |
| 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): | |
| 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 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)) | |
| 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 | |