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

Loss methods in machine learning are strategies to measure how unsuitable a model’s predictions are. They act like a report card, giving lower scores (losses) for increased predictions and higher scores for worse ones. These methods info the tutorial course of by providing a ideas to the model the place it’s making errors and the way in which enormous these errors are. By attempting to cut back this loss score, the model often improves its effectivity. Utterly completely different points (like classification or suggestion) use completely completely different loss methods tailored to their specific targets. Lastly, loss methods are the model’s compass, directing it in course of upper effectivity by way of regular ideas and changes.

On this put up, we’ll be taught regarding the completely completely different loss methods used inside the recommender methods and implement them in python using Numpy.

Following are primarily probably the most typically used loss methods for the recommender methods:

1) Stage-wise Loss

Stage-wise loss options take care of each user-item interaction as an neutral prediction draw back. It objectives to predict the exact rating or selection score for each user-item pair. That’s useful as soon as we get particular score or ideas from the individual (for e.g., # of ⭐️ after watching a youTube video). Indicate Sq. Error (MSE) is actually probably the most typically used loss methodology for this.

Suppose we now have the subsequent predicted & exact rankings:

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

We would calculate the MSE as:

def pointwise_mse_loss(y_true, y_pred):
"""
Computes Indicate Squared Error (MSE) loss
"""
return np.suggest((y_true - y_pred) ** 2)
# Occasion 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 options consider the relative ordering of merchandise pairs. They objective to rank devices relative to 1 one other for an individual, pretty than predicting absolute scores.

2.1) Logistic Loss

The pair-wise logistic loss is used when the individual has equipped particular ideas for devices (e.g., movement photos) and we want to be taught a model that will precisely rank pairs of flicks. Instead of predicting absolute scores, it focuses on the relative order of issues.

Inside the context of recommender methods:

• We take into consideration pairs of issues (i, j) for a given individual
• Merchandise i is most popular over merchandise j (i.e., must be ranked elevated)
• The model predicts scores for every devices
• The loss function encourages the score of merchandise i to be elevated than the score of merchandise j

The intuition behind this loss function is as follows:

We solely take into consideration pairs the place y_i > y_j, i.e., the place merchandise i must be ranked elevated than merchandise j in accordance with the underside truth. For these pairs, we wish the anticipated rankings; s_i > s_j (since our model should predict the subsequent score for the merchandise that must be ranked elevated).

If s_i is method larger than s_j, then exp(-(s_i — s_j)) will be close to 0, and log(1 + exp(-(s_i — s_j))) will be close to 0, resulting in a small loss. If s_i is close to or decrease than s_j, then exp(-(s_i — s_j)) will be close to or bigger than 1, resulting in a larger loss. The log function helps to dampen terribly huge losses and make the optimization further regular.

This loss function encourages the model to be taught to rank devices precisely by penalizing incorrectly ordered pairs.

Let’s break down the tactic:

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

Clarification:

• sum_i sum_j: This displays a double summation over all pairs of issues i and j inside the dataset.
• I[y_i > y_j]: That’s an indicator function. It equals 1 if y_i > y_j, and 0 in every other case. Proper right here, y_i and y_j symbolize the true relevance scores or rankings of issues i and j.
• s_i and s_j: These are the anticipated scores for devices i and j out of your score model.
• exp(-(s_i — s_j)): This time interval computes the exponential of the detrimental distinction between the anticipated scores.
• log(1 + exp(-(s_i — s_j))): That’s the logistic loss for a pair of issues.

def pairwise_logistic_loss(y_true, y_pred) -> float:
"""
Calculate the pairwise logistic loss for a score draw back.
It penalizes incorrectly ordered pairs of issues based totally 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 function that equals 1 when the scenario is true and 0 in every other case.
"""
if len(y_true) != len(y_pred):
improve ValueError("y_true and y_pred might want to have the equivalent measurement")
n = len(y_true)
loss = 0.0
print("nPair-wise contributions:")
for i in differ(n):
for j in differ(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
# Occasion data
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 Score (BPR) Loss

Bayesian Personalised Score loss is one different pair-wise score loss function typically utilized in recommender methods. It’s useful for implicit ideas eventualities, the place we don’t have particular rankings nonetheless implicit indications of individual preferences (e.g., clicks, views, purchases).

BPR optimizes score pretty than predicting absolute rankings. It assumes that the observed (optimistic) devices must be ranked elevated than unobserved devices for an individual. It’s based totally on a Bayesian analysis of the pair-wise score draw back.

The elemental idea of BPR is to maximise the possibility {{that a}} individual prefers an observed merchandise over an unobserved merchandise. Mathematically, for an individual u, an observed merchandise i, and an unobserved merchandise j.

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

Why is it often known as Bayesian?

The “Bayesian” in BPR refers to utilizing a Bayesian analysis of the problem assertion, pretty than utilizing Bayesian inference strategies. The authors [1] formulate the personalized score course of as a most posterior estimation draw back.

• Posterior Chance: BPR objectives to maximise the posterior probability of the personalized rankings. In Bayesian phrases, it’s in search of primarily probably the most doable score given the observed data.
• Prior and Chance:The technique implicitly defines a earlier over the parameters and an opportunity function for the observed pair-wise preferences.
• Most A Posteriori (MAP) Estimation: BPR makes use of a most a posteriori (MAP) estimation technique, which is a Bayesian concept. MAP estimation objectives to look out the mode of the posterior distribution, pretty than computing the whole posterior distribution.
• Probabilistic Interpretation: The sigmoid function utilized in BPR could also be interpreted as a result of the possibility of 1 merchandise being ranked elevated than one different, which aligns with Bayesian probabilistic pondering.

Mathematical Formulation:

Let Θ be the model parameters and >u be the personalized entire score for an individual u. The aim is to maximise:

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

The place:

• Θ: The model parameters (e.g., latent parts in matrix factorization)
• u: The personalized entire score for individual u
• p(Θ | >u): The posterior probability of the parameters given the observed rankings
• p(>u | Θ): The possibility of the observed rankings given the parameters
• p(Θ): The prior probability of the parameters
• ∝: Proportional to (we often ignore the normalizing mounted)

The aim is to look out the parameters Θ that maximize the posterior probability p(Θ | >u).

1. Taking the logarithm: To simplify calculations, we often work with the log of this opportunity. Taking logs of both aspect:
   log p(Θ | >u) = log p(>u | Θ) + log p(Θ)
2. Chance time interval: The possibility p(>u | Θ) is modeled as a product of specific individual pair-wise preferences: p(>u | Θ) = ∏(u,i,j)∈DS p(i >u j | Θ)
   The place DS is the set of all (individual, optimistic merchandise, detrimental merchandise) triples.
3. Modeling specific individual preferences: Each pair-wise selection is modeled using the sigmoid function: p(i >u j | Θ) = σ(x̂_uij(Θ)); the place, x̂_uij(Θ) is the dot product between the individual and distinction between optimistic & detrimental devices
4. Prior time interval: The prior p(Θ) is usually modeled as a conventional distribution, which in log sort 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 rework this to a loss function (which we want to scale back), we negate it: L(Θ) = -∑(u,i,j)∈DS log σ(x̂_uij(Θ)) + λ||Θ||²

Below is a simplified implementation for the BPR loss:

import numpy as np
from typing import File
def sigmoid(x: float):
"""
Function to compute sigmoid
"""
return 1 / (1 + np.exp(-x))
def bpr_loss(individual: File[float], pos_item: File[float], neg_item: File[float]):
"""
Function to compute BPR Loss
Params
-------
individual: individual latent problem found by means of the teaching.
pos_item: predicted rating for the postive merchandise
neg_item: predicted rating for the detrimental merchandise
"""
x_uij = np.dot(individual, pos_item - neg_item)
return -np.log(sigmoid(x_uij))
def l2_reg(params: File[float]):
"""
Function to compute the L2 Regularization
"""
return np.sum(params**2)
def compute_loss(individual, devices, pos_item, neg_item, lambda_reg):
pos_ranks = devices[pos_item]
neg_ranks = devices[neg_item]
loss = bpr_loss(individual, pos_ranks, neg_ranks)
# calculate l2 for each param
reg = lambda_reg * (np.sum([l2_reg(p) for p in [user, pos_ranks, neg_ranks]]))
return loss + reg
lambda_reg = 0.01
# individual and merchandise parts found by means of the Teaching part
individual = np.array([0.1,0.3])
devices = {
'M': np.array([0.04,0.05]), # matrix
'I': np.array([0.03,0.02]), # inception
'T': np.array([0.01,0.02])  # titanic
}
# Teaching data: (individual, 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(individual, devices, 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 different well-liked loss methodology used inside the recommender methods once we now have implicit ideas from the shoppers and the primary goal is to optimize the very best Okay ideas for each individual. It’s identical to BPR as a result of it moreover makes use of the (individual, optimistic, detrimental) triplet to compute pair-wise loss. Nevertheless not like BPR, it estimates the rank of the optimistic merchandise based totally on what variety of sampling makes an try have been needed to find a violating detrimental merchandise.

Principally, it samples a optimistic merchandise, then retains sampling detrimental devices until it finds one which violates the desired score (i.e., pos_item — neg_item < 1).

That’s the methodology for approximating rank and weight:

rank (r) ≈ floor((|I| — 1) / N), the place “I” is the whole number of devices and “N” is the sampling rely

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

Intuitively, it implies that errors for optimistic devices with lower ranks (8 out of 10) get further weight.

Let’s take this occasion to know: Take into consideration, we now have 1000 devices in entire.

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

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

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

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

In State of affairs 1, the pos_item is ranked lower as a result of it solely took a few samples to look out the detrimental merchandise, so the burden is elevated. By assigning the subsequent weight to this pos_item, we intend to manage the model parameters to assign the subsequent score to this merchandise. In State of affairs 2, it took many samples to look out the detrimental merchandise, so the burden is lower. Intuitively, if the anticipated score for the pos_item is extreme, then it would nearly actually take many samples to look out the detrimental merchandise. Which signifies that we don’t need to improve the score of this pos_item.

Proper right here’s the simplified Numpy implementation:

import random
import numpy as np
from typing import File
random.seed(1)
def warp_loss(positive_scores: File, negative_scores: File, 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 check what variety of events detrimental
# merchandise is sampled
rely = 0
for _ in differ(max_trials):
# Sample a detrimental merchandise
neg_idx = np.random.randint(n_neg)
neg_score = negative_scores[neg_idx]
if pos_score - neg_score < 1:
# Violation found
rank = np.floor(tot_items -1)//(rely+1)
# hinge loss
# This encourages the model to rank optimistic devices elevated than 
# detrimental devices by in any case the specified margin (1 on this case).
loss += np.log(rank+1) * max(0, 1 - (pos_score - neg_score))
break
rely += 1
if rely == max_trials:
# No violation found after max_trials
rank = (tot_items -1)//max_trials
loss += np.log(rank)
return loss / n_pos
# Constructive (associated) devices
positive_scores = np.array([0.9, 0.8, 0.7])
# Detrimental (irrelevant) devices
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