Baseline Prediction Using Global Average

Introduction to Recommendation Systems

Welcome to the exciting world of recommendation systems . You've likely experienced the power of these systems when accessing platforms like Netflix, Amazon, or Spotify. Recommendation systems analyze user data to suggest items you might like. The key task in these systems is to predict the rating a user might give to an unseen item. In this lesson, you will learn how to make these predictions using a simple baseline model. Baseline models are essential in recommendation systems, serving as a standard to measure the performance of more complex models. Today, you will explore one such baseline model using global averages.

Understanding the User-Item Rating Matrix

In recommendation systems, the user-item rating matrix is a foundational concept. This matrix helps organize user interactions with different items. Each row represents a user, and each column represents an item. The cell values are the ratings given by users to the items. Rating could be an explicit feedback, where user actually rates an item, for example giving 4 stars to a watch movie. But rating could also be some implicit metric that evaluates how user liked an item. For example, for songs, it could be calculated based on how often user listens to this song. For example, consider the following user-item matrix where users have rated some items: ItemA ItemB ItemC User1 534 User2 312 User3 43 ? Notice the missing rating for User3 on ItemC. This might mean that User3 didn't interact with ItemC. We want to predict what rating User3 would give to ItemC: If this rating is high, we might recommend this item. It's important to note that predicted ratings can be floats, as they represent averages. Even though the example ratings are integers, predictions do not have to be rounded to the nearest integer.

	ItemA	ItemB	ItemC
User1	5	3	4
User2	3	1	2
User3	4	3	?

Creating a User-Item Rating Matrix

Let's create a user-item rating matrix using a Python dictionary. This matrix will be handy when you predict missing ratings. Python# Creating a user-item rating matrix with one missing rating users_items_matrix = { 'User1': {'ItemA': 5, 'ItemB': 3, 'ItemC': 4}, 'User2': {'ItemA': 3, 'ItemB': 1, 'ItemC': 2}, 'User3': {'ItemA': 4, 'ItemB': 3} # User3's rating for ItemC is missing } Here, you have a dictionary representing the ratings given by each user for each item. Notice how User3 has not rated ItemC, which you will predict using a baseline model. In this unit, we do not consider situations where the item is fresh new, meaning it was just added to our database, like a video that was just uploaded. It is known as the 'cold start' problem. We assume that the item is already present in our matrix and has ratings.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Implementing Global Average Baseline Prediction

We wish to start with a simple baseline model, which will pivot future model development. The global average, the average of ratings that the item received from all users, is a simple approach to predicting missing ratings. You can suggest that other users would give this item ratings that are close to the global average.

Here's how you can implement this:

Python

# Baseline model - predicting based on the item's global average
def compute_global_averages(user_ratings):
    total_ratings = {}
    count_ratings = {}
    
    for user, ratings in user_ratings.items():
        for item, rating in ratings.items():
            if item not in total_ratings:
                total_ratings[item] = 0
                count_ratings[item] = 0
            total_ratings[item] += rating
            count_ratings[item] += 1
    
    global_averages = {item: total_ratings[item] / count_ratings[item] for item in total_ratings}
    return global_averages

global_averages = compute_global_averages(users_items_matrix)
predicted_rating_itemC_user3 = global_averages['ItemC']  # Predict User3's rating for ItemC
print(f"Predicted Rating for User3 on ItemC: {predicted_rating_itemC_user3}")  # Predicted Rating for User3 on ItemC: 3.0

# Baseline model - predicting based on the item's global average
def compute_global_averages(user_ratings):
    total_ratings = {}
    count_ratings = {}
    
    for user, ratings in user_ratings.items():
        for item, rating in ratings.items():
            if item not in total_ratings:
                total_ratings[item] = 0
                count_ratings[item] = 0
            total_ratings[item] += rating
            count_ratings[item] += 1
    
    global_averages = {item: total_ratings[item] / count_ratings[item] for item in total_ratings}
    return global_averages

global_averages = compute_global_averages(users_items_matrix)
predicted_rating_itemC_user3 = global_averages['ItemC']  # Predict User3's rating for ItemC
print(f"Predicted Rating for User3 on ItemC: {predicted_rating_itemC_user3}")  # Predicted Rating for User3 on ItemC: 3.0

Let's review the algorithm