Download annotations/annotation_101/CaDiRec/utils.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 8.72 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_101/CaDiRec/utils.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_101/CaDiRec/utils.py
-
curl -L -o utils.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_101/CaDiRec/utils.py
8.72 kB
| import math | |
| import torch | |
| import numpy as np | |
| from scipy.sparse import csr_matrix | |
| import random | |
| import torch.nn as nn | |
| def set_seed(seed): | |
| '''Fix all of random seed for reproducible training''' | |
| random.seed(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 # only add when conv in your model | |
| def recall_at_k(actual, predicted, topk): | |
| sum_recall = 0.0 | |
| num_users = len(predicted) | |
| true_users = 0 | |
| # print("actual", len(actual)) | |
| 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 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 | |
| def get_full_sort_score(epoch, answers, pred_list): | |
| recall, ndcg = [], [] | |
| for k in [5, 10, 15, 20]: | |
| recall.append(recall_at_k(answers, pred_list, k)) | |
| ndcg.append(ndcg_k(answers, pred_list, k)) | |
| post_fix = { | |
| "Epoch": epoch, | |
| "HIT@5": '{:.4f}'.format(recall[0]), "NDCG@5": '{:.4f}'.format(ndcg[0]), | |
| "HIT@10": '{:.4f}'.format(recall[1]), "NDCG@10": '{:.4f}'.format(ndcg[1]), | |
| "HIT@20": '{:.4f}'.format(recall[3]), "NDCG@20": '{:.4f}'.format(ndcg[3]) | |
| } | |
| print(post_fix) | |
| class BPRLoss(nn.Module): | |
| """BPRLoss, based on Bayesian Personalized Ranking | |
| Args: | |
| - gamma(float): Small value to avoid division by zero | |
| Shape: | |
| - Pos_score: (N) | |
| - Neg_score: (N), same shape as the Pos_score | |
| - Output: scalar. | |
| Examples:: | |
| >>> loss = BPRLoss() | |
| >>> pos_score = torch.randn(3, requires_grad=True) | |
| >>> neg_score = torch.randn(3, requires_grad=True) | |
| >>> output = loss(pos_score, neg_score) | |
| >>> output.backward() | |
| """ | |
| def __init__(self, gamma=1e-10): | |
| super(BPRLoss, self).__init__() | |
| self.gamma = gamma | |
| def forward(self, pos_score, neg_score): | |
| loss = -torch.log(self.gamma + torch.sigmoid(pos_score - neg_score)).mean() | |
| return loss | |
| 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 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 gather(consts: torch.Tensor, t: torch.Tensor): | |
| """Gather consts for $t$ and reshape to feature map shape""" | |
| c = consts.gather(-1, t.reshape(-1)) | |
| # print("debug c", c.shape) | |
| return c.reshape(-1, t.shape[-1], 1) | |
| def q_xt_x0(x0, t, alpha_bar): | |
| """get the noised x and noise""" | |
| # alpha_bar: (step_num) | |
| # print("x0", x0.shape) # (B, L, h) | |
| # print("t", t.shape) # (B, L) | |
| # print("alpha_bar", alpha_bar.shape) # (1000) | |
| mean = gather(alpha_bar, t) ** 0.5 * x0 # (bs, max_len, hidden_size) | |
| # print("mean", mean.shape) | |
| var = 1-gather(alpha_bar, t) # (bs, 1, 1, 1) | |
| eps = torch.randn_like(x0).to(x0.device) | |
| return mean + (var ** 0.5) * eps, eps # also returns noise | |
| def compute_alpha(beta, t): | |
| beta = torch.cat([torch.zeros(1).to(beta.device), beta], dim=0) | |
| # print("beta", beta.shape) | |
| # print("t", t.shape) | |
| a = (1 - beta).cumprod(dim=0).index_select(0, t.reshape(-1) + 1).view(t.shape[0],t.shape[1], 1) | |
| # print("a", a.shape) | |
| return a | |
| def p_xt(xt, noise, t, next_t, beta, eta): | |
| at = compute_alpha(beta, t.long()) | |
| at_next = compute_alpha(beta, next_t.long()) | |
| x0_t = (xt - noise * (1 - at).sqrt()) / at.sqrt() | |
| c1 = (eta * ((1 - at / at_next) * (1 - at_next) / (1 - at)).sqrt()) | |
| c2 = ((1 - at_next) - c1 ** 2).sqrt() | |
| eps = torch.randn(xt.shape, device=xt.device) | |
| xt_next = at_next.sqrt() * x0_t + c1 * eps + c2 * noise | |
| return xt_next | |
| 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: | |
| # ({self.score_min:.6f} --> {score:.6f}) # 这里如果是一个值的话输出才不会有问题 | |
| print(f"Validation score increased. Saving model ...") | |
| torch.save(model.state_dict(), self.checkpoint_path) | |
| self.score_min = score | |
| class SiLU(nn.Module): | |
| def forward(self, x): | |
| return x * torch.sigmoid(x) | |
| class GroupNorm32(nn.GroupNorm): | |
| def forward(self, x): | |
| return super().forward(x.float()).type(x.dtype) | |
| def linear(*args, **kwargs): | |
| """ | |
| Create a linear module. | |
| """ | |
| return nn.Linear(*args, **kwargs) | |
| def timestep_embedding(timesteps, dim, max_period=10000): | |
| """ | |
| Create sinusoidal timestep embeddings. | |
| :param timesteps: a 1-D Tensor of N indices, one per batch element. | |
| These may be fractional. | |
| :param dim: the dimension of the output. | |
| :param max_period: controls the minimum frequency of the embeddings. | |
| :return: an [N x dim] Tensor of positional embeddings. | |
| """ | |
| half = dim // 2 | |
| freqs = torch.exp( | |
| -math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32) / half | |
| ).to(device=timesteps.device) | |
| args = timesteps[:, None].float() * freqs[None] | |
| embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1) | |
| if dim % 2: | |
| embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1) | |
| return embedding |