Different Loss Methods for the Recommender Systems | by Mandeep Singh | Jul, 2024

Loss strategies in machine studying are methods to measure how unsuitable a mannequin’s predictions are. They act like a report card, giving decrease scores (losses) for higher predictions and better scores for worse ones. These strategies information the educational course of by offering a suggestions to the mannequin the place it’s making errors and the way huge these errors are. By making an attempt to reduce this loss rating, the mannequin regularly improves its efficiency. Completely different issues (like classification or suggestion) use totally different loss strategies tailor-made to their particular targets. Finally, loss strategies are the mannequin’s compass, directing it in direction of higher efficiency via steady suggestions and adjustments.

On this put up, we’ll be taught concerning the totally different loss strategies used within the recommender techniques and implement them in python utilizing Numpy.

Following are essentially the most generally used loss strategies for the recommender techniques:

1) Level-wise Loss

Level-wise loss features deal with every user-item interplay as an impartial prediction downside. It goals to foretell the precise ranking or choice rating for every user-item pair. That is helpful once we get specific rating or suggestions from the person (for e.g., # of ⭐️ after watching a youTube video). Imply Sq. Error (MSE) is essentially the most generally used loss methodology for this.

Suppose we now have the next predicted & precise rankings:

• Predicted rankings: [4.2, 3.8, 2.5]
• Precise rankings: [4.0, 3.5, 3.0]

We’d calculate the MSE as:

def pointwise_mse_loss(y_true, y_pred):
"""
Computes Imply Squared Error (MSE) loss
"""
return np.imply((y_true - y_pred) ** 2)
# Instance utilization
y_true_ratings = np.array([4.0, 3.5, 3.0])
y_pred_ratings = np.array([4.2, 3.8, 2.5])
loss = pointwise_mse_loss(y_true, y_pred)
print(f"Pointwise MSE Loss: {loss}")

2) Pair-wise Loss

Pair-wise loss features concentrate on the relative ordering of merchandise pairs. They goal to rank gadgets relative to one another for a person, fairly than predicting absolute scores.

2.1) Logistic Loss

The pair-wise logistic loss is used when the person has supplied specific suggestions for gadgets (e.g., motion pictures) and we wish to be taught a mannequin that may accurately rank pairs of flicks. As an alternative of predicting absolute scores, it focuses on the relative order of things.

Within the context of recommender techniques:

• We think about pairs of things (i, j) for a given person
• Merchandise i is most well-liked over merchandise j (i.e., needs to be ranked increased)
• The mannequin predicts scores for each gadgets
• The loss operate encourages the rating of merchandise i to be increased than the rating of merchandise j

The instinct behind this loss operate is as follows:

We solely think about pairs the place y_i > y_j, i.e., the place merchandise i needs to be ranked increased than merchandise j in accordance with the bottom fact. For these pairs, we would like the expected rankings; s_i > s_j (since our mannequin ought to predict the next rating for the merchandise that needs to be ranked increased).

If s_i is way bigger than s_j, then exp(-(s_i — s_j)) can be near 0, and log(1 + exp(-(s_i — s_j))) can be near 0, leading to a small loss. If s_i is near or lower than s_j, then exp(-(s_i — s_j)) can be near or larger than 1, leading to a bigger loss. The log operate helps to dampen extraordinarily massive losses and make the optimization extra steady.

This loss operate encourages the mannequin to be taught to rank gadgets accurately by penalizing incorrectly ordered pairs.

Let’s break down the method:

loss = sum_i sum_j I[y_i > y_j] * log(1 + exp(-(s_i — s_j)))

Clarification:

• sum_i sum_j: This exhibits a double summation over all pairs of things i and j within the dataset.
• I[y_i > y_j]: That is an indicator operate. It equals 1 if y_i > y_j, and 0 in any other case. Right here, y_i and y_j symbolize the true relevance scores or rankings of things i and j.
• s_i and s_j: These are the expected scores for gadgets i and j out of your rating mannequin.
• exp(-(s_i — s_j)): This time period computes the exponential of the detrimental distinction between the expected scores.
• log(1 + exp(-(s_i — s_j))): That is the logistic loss for a pair of things.

def pairwise_logistic_loss(y_true, y_pred) -> float:
"""
Calculate the pairwise logistic loss for a rating downside.
It penalizes incorrectly ordered pairs of things primarily based on their true and predicted scores.
The loss is calculated as:
loss = sum_i sum_j I[y_true_i > y_true_j] * log(1 + exp(-(y_pred_i - y_pred_j)))
the place I[condition] is an indicator operate that equals 1 when the situation is true and 0 in any other case.
"""
if len(y_true) != len(y_pred):
increase ValueError("y_true and y_pred will need to have the identical size")
n = len(y_true)
loss = 0.0
print("nPair-wise contributions:")
for i in vary(n):
for j in vary(n):
if y_true[i] > y_true[j]:
pair_loss = np.log(1 + np.exp(-(y_pred[i] - y_pred[j])))
loss += pair_loss
print(f"Pair ({i}, {j}) with preds ({y_pred[i]},{y_pred[j]}): Loss = {pair_loss:.4f}")
return loss
# Instance knowledge
y_true = np.array([10, 2, 4, 1])  # True relevance scores
s_pred = np.array([12.5, 2.0, 3.5, 1.5])  # Predicted scores
# Calculate loss
loss = pairwise_logistic_loss(y_true, s_pred)
print(f"Pairwise Logistic Loss: {loss}")
Pair-wise contributions:
Pair (0, 1) with preds (12.5,2.0): Loss = 0.0000
Pair (0, 2) with preds (12.5,3.5): Loss = 0.0001
Pair (0, 3) with preds (12.5,1.5): Loss = 0.0000
Pair (1, 3) with preds (2.0,1.5): Loss = 0.4741
Pair (2, 1) with preds (3.5,2.0): Loss = 0.2014
Pair (2, 3) with preds (3.5,1.5): Loss = 0.1269
Pairwise Logistic Loss: 0.8025859130271021

2.2) Bayesian Personalised Rating (BPR) Loss

Bayesian Personalised Rating loss is one other pair-wise rating loss operate generally utilized in recommender techniques. It’s helpful for implicit suggestions eventualities, the place we don’t have specific rankings however implicit indications of person preferences (e.g., clicks, views, purchases).

BPR optimizes rating fairly than predicting absolute rankings. It assumes that the noticed (optimistic) gadgets needs to be ranked increased than unobserved gadgets for a person. It’s primarily based on a Bayesian evaluation of the pair-wise rating downside.

The fundamental concept of BPR is to maximise the chance {that a} person prefers an noticed merchandise over an unobserved merchandise. Mathematically, for a person u, an noticed merchandise i, and an unobserved merchandise j.

The BPR loss operate is then outlined as:
L = -ln(σ(x̂_uij)) + λ||Θ||²
The place λ is a regularization parameter and ||Θ||² is the L2 norm of the mannequin parameters.

Why is it known as Bayesian?

The “Bayesian” in BPR refers to using a Bayesian evaluation of the issue assertion, fairly than using Bayesian inference methods. The authors [1] formulate the customized rating process as a most posterior estimation downside.

• Posterior Likelihood: BPR goals to maximise the posterior chance of the customized rankings. In Bayesian phrases, it’s looking for essentially the most possible rating given the noticed knowledge.
• Prior and Probability:The strategy implicitly defines a previous over the parameters and a chance operate for the noticed pair-wise preferences.
• Most A Posteriori (MAP) Estimation: BPR makes use of a most a posteriori (MAP) estimation strategy, which is a Bayesian idea. MAP estimation goals to search out the mode of the posterior distribution, fairly than computing the total posterior distribution.
• Probabilistic Interpretation: The sigmoid operate utilized in BPR may be interpreted because the chance of 1 merchandise being ranked increased than one other, which aligns with Bayesian probabilistic pondering.

Mathematical Formulation:

Let Θ be the mannequin parameters and >u be the customized whole rating for a person u. The purpose is to maximise:

p(Θ | >u) ∝ p(>u | Θ) p(Θ)

The place:

• Θ: The mannequin parameters (e.g., latent components in matrix factorization)
• u: The customized whole rating for person u
• p(Θ | >u): The posterior chance of the parameters given the noticed rankings
• p(>u | Θ): The chance of the noticed rankings given the parameters
• p(Θ): The prior chance of the parameters
• ∝: Proportional to (we frequently ignore the normalizing fixed)

The purpose is to search out the parameters Θ that maximize the posterior chance p(Θ | >u).

1. Taking the logarithm: To simplify calculations, we frequently work with the log of this chance. Taking logs of either side:
   log p(Θ | >u) = log p(>u | Θ) + log p(Θ)
2. Probability time period: The chance p(>u | Θ) is modeled as a product of particular person pair-wise preferences: p(>u | Θ) = ∏(u,i,j)∈DS p(i >u j | Θ)
   The place DS is the set of all (person, optimistic merchandise, detrimental merchandise) triples.
3. Modeling particular person preferences: Every pair-wise choice is modeled utilizing the sigmoid operate: p(i >u j | Θ) = σ(x̂_uij(Θ)); the place, x̂_uij(Θ) is the dot product between the person and distinction between optimistic & detrimental gadgets
4. Prior time period: The prior p(Θ) is often modeled as a traditional distribution, which in log type turns into proportional to the detrimental L2 norm of the parameters.
5. The log posterior turns into:
   log p(Θ | >u) ∝ ∑(u,i,j)∈DS log σ(x̂_uij(Θ)) — λ||Θ||²

To transform this to a loss operate (which we wish to reduce), we negate it: L(Θ) = -∑(u,i,j)∈DS log σ(x̂_uij(Θ)) + λ||Θ||²

Under is a simplified implementation for the BPR loss:

import numpy as np
from typing import Record
def sigmoid(x: float):
"""
Operate to compute sigmoid
"""
return 1 / (1 + np.exp(-x))
def bpr_loss(person: Record[float], pos_item: Record[float], neg_item: Record[float]):
"""
Operate to compute BPR Loss
Params
-------
person: person latent issue discovered through the coaching.
pos_item: predicted ranking for the postive merchandise
neg_item: predicted ranking for the detrimental merchandise
"""
x_uij = np.dot(person, pos_item - neg_item)
return -np.log(sigmoid(x_uij))
def l2_reg(params: Record[float]):
"""
Operate to compute the L2 Regularization
"""
return np.sum(params**2)
def compute_loss(person, gadgets, pos_item, neg_item, lambda_reg):
pos_ranks = gadgets[pos_item]
neg_ranks = gadgets[neg_item]
loss = bpr_loss(person, pos_ranks, neg_ranks)
# calculate l2 for every param
reg = lambda_reg * (np.sum([l2_reg(p) for p in [user, pos_ranks, neg_ranks]]))
return loss + reg
lambda_reg = 0.01
# person and merchandise components discovered through the Coaching section
person = np.array([0.1,0.3])
gadgets = {
'M': np.array([0.04,0.05]), # matrix
'I': np.array([0.03,0.02]), # inception
'T': np.array([0.01,0.02])  # titanic
}
# Coaching knowledge: (person, positive_item, negative_item)
training_data = [('M', 'I'), ('M', 'T'), ('I', 'T')]
total_loss = 0
for pos_item, neg_item in training_data:
# Compute loss
loss = compute_loss(person, gadgets, pos_item, neg_item, lambda_reg)
total_loss += loss
print(f"Loss: {total_loss}")

2.3) Weighted Approximate-Rank Pair-wise (WARP) Loss

WARP is one other well-liked loss methodology used within the recommender techniques when we now have implicit suggestions from the customers and the first purpose is to optimize the highest Okay suggestions for every person. It’s just like BPR because it additionally makes use of the (person, optimistic, detrimental) triplet to compute pair-wise loss. However not like BPR, it estimates the rank of the optimistic merchandise primarily based on what number of sampling makes an attempt have been wanted to discover a violating detrimental merchandise.

Principally, it samples a optimistic merchandise, then retains sampling detrimental gadgets till it finds one which violates the specified rating (i.e., pos_item — neg_item < 1).

That is the method for approximating rank and weight:

rank (r) ≈ ground((|I| — 1) / N), the place “I” is the entire variety of gadgets and “N” is the sampling depend

weight = Φ(r) = log(r + 1)

Intuitively, it implies that errors for optimistic gadgets with decrease ranks (8 out of 10) get extra weight.

Let’s take this instance to grasp: Think about, we now have 1000 gadgets in whole.

State of affairs 1: It takes 2 samples to search out the detrimental merchandise.

• rank = ground((1000–1) / 2) = 499
• Weight = log(499+1) = 6.2

State of affairs 2: It takes 100 samples to search out the detrimental merchandise.

• rank = ground((1000–1) / 100) = 9
• Weight = log(9+1) = 2.3

In State of affairs 1, the pos_item is ranked decrease because it solely took a couple of samples to search out the detrimental merchandise, so the burden is increased. By assigning the next weight to this pos_item, we intend to regulate the mannequin parameters to assign the next rating to this merchandise. In State of affairs 2, it took many samples to search out the detrimental merchandise, so the burden is decrease. Intuitively, if the expected rating for the pos_item is excessive, then it might almost certainly take many samples to search out the detrimental merchandise. Which means that we don’t want to enhance the rating of this pos_item.

Right here’s the simplified Numpy implementation:

import random
import numpy as np
from typing import Record
random.seed(1)
def warp_loss(positive_scores: Record, negative_scores: Record, max_trials: int=100):
n_pos = len(positive_scores)
n_neg = len(negative_scores)
tot_items = n_pos + n_neg
loss = 0
for pos_score in positive_scores:
# counter to test what number of occasions detrimental
# merchandise is sampled
depend = 0
for _ in vary(max_trials):
# Pattern a detrimental merchandise
neg_idx = np.random.randint(n_neg)
neg_score = negative_scores[neg_idx]
if pos_score - neg_score < 1:
# Violation discovered
rank = np.ground(tot_items -1)//(depend+1)
# hinge loss
# This encourages the mannequin to rank optimistic gadgets increased than 
# detrimental gadgets by at the least the desired margin (1 on this case).
loss += np.log(rank+1) * max(0, 1 - (pos_score - neg_score))
break
depend += 1
if depend == max_trials:
# No violation discovered after max_trials
rank = (tot_items -1)//max_trials
loss += np.log(rank)
return loss / n_pos
# Constructive (related) gadgets
positive_scores = np.array([0.9, 0.8, 0.7])
# Detrimental (irrelevant) gadgets
negative_scores = np.array([0.6, 0.5, 0.4, 0.3, 0.2])
loss = warp_loss(positive_scores, negative_scores)
print(f"WARP Loss: {loss}")

1. Bayesian Personalized Ranking from Implicit Feedback
2. https://www.tensorflow.org/ranking/api_docs/python/tfr/keras/losses/PairwiseLogisticLoss
3. https://making.lyst.com/lightfm/docs/examples/warp_loss.html
4. Learning to Rank Recommendations with the k-Order Statistic Loss
5. https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/tr-2007-40.pdf