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.

A baseline model is a simple, easy-to-implement method used to make predictions. Its main purpose is not to be highly accurate, but to provide a reference point or benchmark against which more advanced models can be compared. 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.

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:

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.

Let's create a user-item rating matrix using appropriate data structures. We can use a combination of std::unordered_map and std::map to represent the ratings given by each user for each item. This matrix will be handy when you predict missing ratings.

Below is an example of how to represent the user-item rating matrix:

#include <map>
#include <string>
#include <unordered_map>

// Type alias for a user's ratings.
using ItemRatings = std::map<std::string, double>;
// Type alias for the main data structure.
using RatingsMap = std::unordered_map<std::string, ItemRatings>;

int main() {
    RatingsMap users{
        {"User1", {{"ItemA", 5.0}, {"ItemB", 3.0}, {"ItemC", 4.0}}},
        {"User2", {{"ItemA", 3.0}, {"ItemB", 1.0}, {"ItemC", 2.0}}},
        {"User3", {{"ItemA", 4.0}, {"ItemB", 3.0}}} // User3's rating for ItemC is missing
    };
    // ... (rest of the code)
    return 0;
}

Here, users is an unordered_map where each key is a user name (like User1), and the value is a map from item names (like ItemA) to their ratings (as double). 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 brand new, meaning it was just added to our database, like a video that was just uploaded. This is known as the cold start problem. We assume that the item is already present in our matrix and has ratings.