Download annotations/annotation_37/AlphaRec/models/General/XSimGCL.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 5.47 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_37/AlphaRec/models/General/XSimGCL.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_37/AlphaRec/models/General/XSimGCL.py
-
curl -L -o XSimGCL.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_37/AlphaRec/models/General/XSimGCL.py
5.47 kB
| import numpy as np | |
| import time | |
| import torch | |
| import torch.nn as nn | |
| import torch.nn.functional as F | |
| from .base.abstract_model import AbstractModel | |
| from .base.abstract_RS import AbstractRS | |
| from .base.abstract_data import AbstractData | |
| from tqdm import tqdm | |
| class XSimGCL_RS(AbstractRS): | |
| def __init__(self, args, special_args) -> None: | |
| super().__init__(args, special_args) | |
| self.neg_sample = args.neg_sample if args.neg_sample!=-1 else self.batch_size-1 | |
| def train_one_epoch(self, epoch): | |
| running_loss, running_mf_loss, running_cl_loss, running_reg_loss, num_batches = 0, 0, 0, 0, 0 | |
| pbar = tqdm(enumerate(self.data.train_loader), mininterval=2, total = len(self.data.train_loader)) | |
| for batch_i, batch in pbar: | |
| batch = [x.cuda(self.device) for x in batch] | |
| users, pos_items, users_pop, pos_items_pop = batch[0], batch[1], batch[2], batch[3] | |
| if self.args.infonce == 0 or self.args.neg_sample != -1: | |
| neg_items = batch[4] | |
| neg_items_pop = batch[5] | |
| self.model.train() | |
| mf_loss, cl_loss, reg_loss = self.model(users, pos_items, neg_items) | |
| loss = mf_loss + cl_loss + reg_loss | |
| self.optimizer.zero_grad() | |
| loss.backward() | |
| self.optimizer.step() | |
| running_loss += loss.detach().item() | |
| running_mf_loss += mf_loss.detach().item() | |
| running_cl_loss += cl_loss.detach().item() | |
| running_reg_loss += reg_loss.detach().item() | |
| num_batches += 1 | |
| return [running_loss/num_batches, running_mf_loss/num_batches, running_cl_loss/num_batches, running_reg_loss/num_batches] | |
| class XSimGCL(AbstractModel): | |
| def __init__(self, args, data) -> None: | |
| super().__init__(args, data) | |
| self.temp_cl = args.temp_cl | |
| self.layer_cl = args.layer_cl | |
| self.lambda_cl = args.lambda_cl | |
| self.eps_XSimGCL = args.eps_XSimGCL | |
| def compute(self, perturbed=False): | |
| users_emb = self.embed_user.weight | |
| items_emb = self.embed_item.weight | |
| all_emb = torch.cat([users_emb, items_emb]) | |
| embs = [] | |
| emb_cl = all_emb | |
| g_droped = self.Graph | |
| for layer in range(self.n_layers): | |
| all_emb = torch.sparse.mm(g_droped, all_emb) | |
| if perturbed: | |
| random_noise = torch.rand_like(all_emb).cuda(self.device) # add noise | |
| all_emb += torch.sign(all_emb) * F.normalize(random_noise, dim=-1) * self.eps_XSimGCL | |
| embs.append(all_emb) | |
| if layer==self.layer_cl-1: | |
| emb_cl = all_emb | |
| embs = torch.stack(embs, dim=1) | |
| light_out = torch.mean(embs, dim=1) | |
| users, items = torch.split(light_out, [self.data.n_users, self.data.n_items]) | |
| users_cl, items_cl = torch.split(emb_cl, [self.data.n_users, self.data.n_items]) # view of noise | |
| if perturbed: | |
| return users, items, users_cl, items_cl | |
| return users, items | |
| def InfoNCE(self, view1, view2, temperature, b_cos = True): | |
| if b_cos: | |
| view1, view2 = F.normalize(view1, dim=1), F.normalize(view2, dim=1) | |
| pos_score = (view1 * view2).sum(dim=-1) | |
| pos_score = torch.exp(pos_score / temperature) | |
| ttl_score = torch.matmul(view1, view2.transpose(0, 1)) | |
| ttl_score = torch.exp(ttl_score / temperature).sum(dim=1) | |
| cl_loss = -torch.log(pos_score / ttl_score+10e-6) | |
| return torch.mean(cl_loss) | |
| def cal_cl_loss(self, idx, user_view1,user_view2,item_view1,item_view2): | |
| # 算的一个batch中的 | |
| u_idx = torch.unique(torch.Tensor(idx[0]).type(torch.long)).cuda(self.device) | |
| i_idx = torch.unique(torch.Tensor(idx[1]).type(torch.long)).cuda(self.device) | |
| user_cl_loss = self.InfoNCE(user_view1[u_idx], user_view2[u_idx], self.temp_cl) | |
| item_cl_loss = self.InfoNCE(item_view1[i_idx], item_view2[i_idx], self.temp_cl) | |
| return user_cl_loss + item_cl_loss | |
| def forward(self, users, pos_items, neg_items): | |
| all_users, all_items, all_users_cl, all_items_cl = self.compute(perturbed=True) | |
| users_emb = all_users[users] | |
| pos_emb = all_items[pos_items] | |
| neg_emb = all_items[neg_items] | |
| userEmb0 = self.embed_user(users) | |
| posEmb0 = self.embed_item(pos_items) | |
| negEmb0 = self.embed_item(neg_items) | |
| # contrastive loss | |
| cl_loss = self.lambda_cl * self.cal_cl_loss([users,pos_items], all_users, all_users_cl, all_items, all_items_cl) | |
| # main loss | |
| # use cosine similarity to calculate the scores | |
| if(self.train_norm == True): | |
| users_emb = F.normalize(users_emb, dim = -1) | |
| pos_emb = F.normalize(pos_emb, dim = -1) | |
| neg_emb = F.normalize(neg_emb, dim = -1) | |
| pos_scores = torch.sum(torch.mul(users_emb, pos_emb), dim=1) # users, pos_items, neg_items have the same shape | |
| neg_scores = torch.sum(torch.mul(users_emb, neg_emb), dim=1) | |
| maxi = torch.log(torch.sigmoid(pos_scores - neg_scores) + 1e-6) | |
| mf_loss = torch.negative(torch.mean(maxi)) | |
| # regularizer loss | |
| regularizer = 0.5 * torch.norm(userEmb0) ** 2 + 0.5 * torch.norm(posEmb0) ** 2 + 0.5 * torch.norm(negEmb0) ** 2 | |
| regularizer = regularizer / self.batch_size | |
| reg_loss = self.decay * regularizer | |
| return mf_loss, cl_loss, reg_loss |