def step(self, user, item):
u_e = self.user_embedding[user]
i_e = self.item_embedding[item]
u_e = u_e.unsqueeze(dim=1)
reward = (-1) * euclidean_distance(u_e, i_e)
return reward
def forward(self, user, pos, neg, **kwargs):
u_e = self.user_embedding[user]
pos_e = self.item_embedding[pos]
neg_e = self.item_embedding[neg]
negs_e = self.item_embedding[kwargs["negs"]]
reg_loss = self.regs * l2_loss(u_e, pos_e, neg_e, negs_e)
pos_d = euclidean_distance(u_e, pos_e)
neg_d = euclidean_distance(u_e, neg_e)
negs_d = euclidean_distance(u_e.unsqueeze(dim=1), negs_e)
impostor = (pos_d.unsqueeze(dim=1) - negs_d + self.margin > 0).float()
rank = torch.mean(impostor, dim=1) * self.n_user
hinge_loss = torch.sum(
torch.log(rank + 1) *
torch.clamp(self.margin + pos_d - neg_d, min=0))
return hinge_loss, reg_loss
def get_score_v2(model, train_user_dict, s, t):
u_e = model.user_embedding[s:t, :]
i_e = model.item_embedding
if model.name == "NMRN":
u_e = u_e.unsqueeze(dim=1)
score_matrix = (-1) * euclidean_distance(u_e, i_e)
else:
score_matrix = torch.matmul(u_e, i_e.t())
if hasattr(model, "bias"):
score_matrix = score_matrix + model.bias
for u in range(s, t):
pos = train_user_dict[u]
score_matrix[u - s][pos] = -1e5
return score_matrix
def throw(self, user, items):
u_e = self.user_embedding[user]
i_e = self.item_embedding[items]
u_e = self.umlp(u_e)
i_e = self.imlp(i_e)
u_e = u_e.unsqueeze(dim=1)
distance = euclidean_distance(u_e, i_e)
prob = F.softmax(-distance, dim=1)
sampled_id = torch.multinomial(prob, num_samples=1)
row_idx = get_row_index(u_e)
good_neg = items[row_idx, sampled_id].squeeze()
return good_neg
def forward(self, user, items, reward):
u_e = self.umlp(self.user_embedding[user])
i_e = self.imlp(self.item_embedding[items])
u_e = u_e.unsqueeze(dim=1)
distance = euclidean_distance(u_e, i_e)
probs = F.softmax(-distance, dim=1)
sampled_id = torch.multinomial(probs, num_samples=1)
row_ids = get_row_index(u_e)
log_probs = F.log_softmax(-distance, dim=-1)
sampled_probs = log_probs[row_ids, sampled_id]
sampled_reward = reward[row_ids, sampled_id]
gan_loss = -torch.mean(sampled_probs * sampled_reward)
reg_loss = self.regs * l2_loss(u_e, i_e)
return gan_loss, reg_loss