mcy98's picture
Upload folder using huggingface_hub
6077218 verified
Raw History Blame Contribute Delete
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