In this lesson, we will explore the concept of novelty in recommendation systems, a key aspect that complements your understanding of metrics like coverage, discussed in the previous lesson. Novelty measures how unexpected or unique the recommended items are to users. A high novelty score indicates that your recommendation system is providing items that users are less likely to have encountered before, potentially leading to increased engagement and user satisfaction. Balancing novelty with relevance is crucial, as overly novel recommendations may not align with user interests.

Let's briefly discuss the setup we will use as an example for this lesson. Here's a simple setup that prepares us to focus on novelty:

Python
Copy to clipboard
1# Basic setup reminder for context
2item_popularity = {1: 80, 2: 50, 3: 30, 4: 20, 5: 5, 6: 5, 7: 5}
3predicted_items = [1, 5, 3]
4total_users = 100  # Example total number of users

This setup includes a dictionary item_popularity representing how often each item appears among users, a list of predicted_items that our system has recommended, and a total_users count.

Novelty quantifies the freshness or unexpectedness of recommendations. We calculate it using the popularity data of the items. Here's how it works conceptually:

• Item Popularity: The frequency with which an item is recommended or interacted with by users. It is important that we can treat this popularity as probability of recommending an item to a user.
• Logarithmic Probability: We use logarithms to assign higher novelty scores to items with lower probability/popularity.
• Normalization: Dividing the sum by the number of predicted items gives us an average novelty score.

We'll now break down the code used to calculate the novelty score step-by-step.

Python
Copy to clipboard
1import math
2
3def novelty(predicted_items, item_popularity, total_users):
4    sum_log_probabilities = sum(
5        -math.log(item_popularity.get(item, 0) / total_users)
6        for item in predicted_items if item in item_popularity
7    )
8    return sum_log_probabilities / len(predicted_items)
9
10# Example data
11item_popularity = {1: 80, 2: 50, 3: 30, 4: 20, 5: 5, 6: 5, 7: 5}
12predicted_items = [1, 5, 3]
13total_users = 100  # Example total number of users
14
15novelty_score = novelty(predicted_items, item_popularity, total_users)
16print(f"Novelty: {novelty_score:.2f}")  # 1.47

1. Import Libraries: We start by importing the math library for logarithmic calculations.
2. Function Definition: The novelty function takes predicted_items, item_popularity, and total_users as inputs.
3. Logarithmic Probability Calculation: Using a generator expression, we calculate the logarithm of the inverse probability of each predicted item. The get method with a default value of 0 ensures we handle items not in item_popularity.
4. Summation and Averaging: We sum the negative logarithms for all items in predicted_items and divide by the length of predicted_items to compute the average, returning this value as the novelty score.

The obtained score indicates a moderate level of novelty across the predicted items.

In some cases, a recommended item might not be present in the item_popularity dictionary. This situation can occur if the item is new or rarely interacted with. To manage such cases, we can assign a default popularity value when an item is not found. This can be achieved using the get method with a default value:

Python
Copy to clipboard
1import math
2
3# Default value handling when an item is not in item_popularity
4DEFAULT_POPULARITY = 1  # Default assumption of minimal popularity 
5
6def novelty(predicted_items, item_popularity, total_users):
7    sum_log_probabilities = sum(
8        -math.log(item_popularity.get(item, DEFAULT_POPULARITY) / total_users)
9        for item in predicted_items
10    )
11    return sum_log_probabilities / len(predicted_items)
12
13# Example data with missing item
14item_popularity = {1: 80, 2: 50, 3: 30, 4: 20}
15predicted_items = [1, 5, 3]  # Assuming 5 is not in item_popularity
16total_users = 100  # Example total number of users
17
18novelty_score = novelty(predicted_items, item_popularity, total_users)
19print(f"Novelty with default handling: {novelty_score:.2f}")  # 2.01

In this example, if an item is not found in item_popularity, we assume it has a minimal popularity, thus contributing to the novelty score calculation with higher unexpectedness. This approach ensures robust handling of recommendations without prior popularity data.

Novelty in recommendation systems significantly impacts various industries. For instance, in e-commerce platforms, suggesting novel products can encourage users to explore new options, potentially increasing sales and user engagement. In entertainment services like streaming platforms, introducing users to less popular content can foster content discovery and enhance user satisfaction.

Understanding where and how to apply novelty helps in creating systems that can enhance the overall user experience by providing unexpected yet interesting recommendations.

In this lesson, we dove into the calculation of novelty, providing insights into its importance and implications in recommendation systems. You now know how to implement a novelty score and can see how it balances with relevance to optimize user engagement.

Congratulations on reaching the end of this course! You've learned about key metrics that determine the effectiveness and reach of recommendation systems. As you explore the practice exercises, you'll get hands-on experience in applying these concepts to real-world data, further honing your skills in building robust recommendation systems.