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