Introduction to Recommendation Systems and Baseline Prediction in JavaScript

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 item averages (also called the per-item mean).

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. A rating could be explicit feedback, where a user actually rates an item, for example, giving 4 stars to a movie. But a rating could also be some implicit metric that evaluates how much a user liked an item. For example, for songs, it could be calculated based on how often a user listens to the 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. Note: Also, in this course, we assume a 1-5 rating scale. In practice, predicted ratings can sometimes fall outside this range (for example, below 1 or above 5) due to averaging or other algorithms. It is common to "clip" or "clamp" predictions to stay within the valid range (e.g., always output a value between 1 and 5). For now, our predictions are unconstrained, but keep in mind that clipping is a standard step in real-world systems.

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

Join the 1M+ learners on CodeSignal

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

Implementing Item Average (Per-Item Mean) Baseline Prediction

We wish to start with a simple baseline model, which will serve as a reference for future model development. The item average (also called the per-item mean), 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 item average.

Here's how you can implement this in JavaScript:

JavaScript

// Baseline model - predicting based on the item's average (per-item mean)
function computeItemAverages(userRatings) {
    const totalRatings = {};
    const countRatings = {};

    for (const user in userRatings) {
        const ratings = userRatings[user];
        for (const item in ratings) {
            const rating = ratings[item];
            if (totalRatings[item] === undefined) {
                totalRatings[item] = 0;
                countRatings[item] = 0;
            }
            totalRatings[item] += rating;
            countRatings[item] += 1;
        }
    }

    const itemAverages = {};
    for (const item in totalRatings) {
        itemAverages[item] = totalRatings[item] / countRatings[item];
    }
    return itemAverages;
}

const itemAverages = computeItemAverages(usersItemsMatrix);
const predictedRatingItemCUser3 = itemAverages['ItemC']; // Predict User3's rating for ItemC
console.log("Predicted Rating for User3 on ItemC:", predictedRatingItemCUser3); // Predicted Rating for User3 on ItemC: 3

Let's review the algorithm:

Initialization:
- totalRatings: An object to store the sum of all ratings for each item.
- countRatings: An object to store the count of ratings for each item.
Iterating through User Ratings:
- For each user and their corresponding ratings, iterate through the items they have rated.
- If an item is encountered for the first time, initialize its entry in both totalRatings and countRatings to zero.
- Add the current rating to the totalRatings for the respective item.
- Increment the count for this item in countRatings.
Compute Item Averages:
- For each item, compute the average by dividing the total ratings by the count of ratings.
- This results in itemAverages, which holds the average rating of each item.
Prediction:
- To predict the rating for User3 on ItemC, retrieve the item's average from the itemAverages object.