Content Based Recommendation Systems

Introduction to Content-Based Recommendation Systems

Welcome to the beginning of our journey into content-based recommendation systems . In the grand scope of recommendation technologies, these systems play a crucial role. They allow applications to suggest relevant items to users based on various content features, enhancing the user experience through personalization. Imagine a music app recommending songs based on the characteristics of songs that a user has liked or listened to in the past. That's the power of a content-based system! In this lesson, we will delve into how content features are extracted to create efficient recommendations, setting a solid foundation for more advanced techniques.

Dataset Overview and Setup

Let's start by revisiting the datasets we will be working with: tracks.json and authors.json. These JSON files contain essential information about music tracks and artists, respectively. Here is an example of how this can work: JSON# tracks [ { "track_id": "001", "title": "Song A", "likes": 150, "clicks": 300, "full_listens": 120, "author_id": "A1" }, ... more tracks ] JSON# authors [ { "author_id": "A1", "name": "Artist X", "author_listeners": 5000, "genre": "Rock" }, ... more authors ] Note that we link a track to its author using the author_id field.

Constructing DataFrames

In C++, we will use the DataFrame library to represent our tabular data. Unlike in some other environments, we will manually construct our dataframes by providing the data directly in the code. This approach gives us full control and clarity over the data structure. Here is how we can manually create the dataframes for tracks and authors: C++#include <iostream> #include <vector> #include <string> #include <DataFrame/DataFrame.h> using namespace hmdf; int main() { // Create tracks dataframe manually StdDataFrame<unsigned long> tracks_df; // Add index std::vector<unsigned long> track_indices = {0, 1, 2}; tracks_df.load_index(std::move(track_indices)); // Add track data std::vector<std::string> track_ids = {"001", "002", "003"}; std::vector<std::string> titles = {"Song A", "Song B", "Song C"}; std::vector<int> likes = {150, 200, 100}; std::vector<int> clicks = {300, 400, 250}; std::vector<int> full_listens = {120, 180, 95}; std::vector<std::string> author_ids = {"A1", "A2", "A3"}; tracks_df.load_column("track_id", std::move(track_ids)); tracks_df.load_column("title", std::move(titles)); tracks_df.load_column("likes", std::move(likes)); tracks_df.load_column("clicks", std::move(clicks)); tracks_df.load_column("full_listens", std::move(full_listens)); tracks_df.load_column("author_id", std::move(author_ids)); // Create authors dataframe manually StdDataFrame<unsigned long> authors_df; // Add index std::vector<unsigned long> author_indices = {0, 1, 2}; authors_df.load_index(std::move(author_indices)); // Add author data std::vector<std::string> author_ids_df = {"A1", "A2", "A3"}; std::vector<std::string> names = {"Artist X", "Artist Y", "Artist Z"}; std::vector<int> author_listeners = {5000, 8000, 3000}; std::vector<std::string> genres = {"Rock", "Pop", "Jazz"}; authors_df.load_column("author_id", std::move(author_ids_df)); authors_df.load_column("name", std::move(names)); authors_df.load_column("author_listeners", std::move(author_listeners)); authors_df.load_column("genre", std::move(genres)); // ... (rest of the code will go here) return 0; } After this step, the dataframes tracks_df and authors_df are ready and contain the following data: tracks_df: text track_id title likes clicks full_listens author_id 0 001 Song A 150 300 120 A1 1 002 Song B 200 400 180 A2 2 003 Song C 100 250 95 A3 authors_df: text author_id name author_listeners genre 0 A1 Artist X 5000 Rock 1 A2 Artist Y 8000 Pop 2 A3 Artist Z 3000 Jazz These dataframes are tabular structures, similar to spreadsheets, where data can be easily processed and analyzed.

Join the 1M+ learners on CodeSignal

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

Combining DataFrames

To make meaningful recommendations, we need to combine information about tracks and authors. In C++, the DataFrame library does not provide a direct "merge" function like some other environments. Instead, we can combine the relevant columns by matching the author_id fields in both dataframes.

For simplicity, since our data is aligned and small, we can access the columns directly by index. In a more general case, you would write code to match rows by author_id. Here, we assume the order matches for demonstration purposes.

C++

    // Display the merged data by accessing columns directly
    std::cout << "Merged Data:" << std::endl;
    std::cout << "Track ID | Title  | Likes | Clicks | Full Listens | Author ID | Name      | Author Listeners | Genre" << std::endl;
    std::cout << "---------|--------|-------|--------|--------------|-----------|-----------|------------------|------" << std::endl;
    
    const auto& track_ids_col = tracks_df.get_column<std::string>("track_id");
    const auto& titles_col = tracks_df.get_column<std::string>("title");
    const auto& likes_col = tracks_df.get_column<int>("likes");
    const auto& clicks_col = tracks_df.get_column<int>("clicks");
    const auto& full_listens_col = tracks_df.get_column<int>("full_listens");
    const auto& author_ids_col = tracks_df.get_column<std::string>("author_id");
    const auto& names_col = authors_df.get_column<std::string>("name");
    const auto& author_listeners_col = authors_df.get_column<int>("author_listeners");
    const auto& genres_col = authors_df.get_column<std::string>("genre");
    
    for (size_t i = 0; i < track_ids_col.size(); ++i) {
        std::cout << track_ids_col[i] << "      | "
                  << titles_col[i] << " | "
                  << likes_col[i] << "   | "
                  << clicks_col[i] << "   | "
                  << full_listens_col[i] << "          | "
                  << author_ids_col[i] << "      | "
                  << names_col[i] << " | "
                  << author_listeners_col[i] << "             | "
                  << genres_col[i] << std::endl;
    }

    // Display the merged data by accessing columns directly
    std::cout << "Merged Data:" << std::endl;
    std::cout << "Track ID | Title  | Likes | Clicks | Full Listens | Author ID | Name      | Author Listeners | Genre" << std::endl;
    std::cout << "---------|--------|-------|--------|--------------|-----------|-----------|------------------|------" << std::endl;
    
    const auto& track_ids_col = tracks_df.get_column<std::string>("track_id");
    const auto& titles_col = tracks_df.get_column<std::string>("title");
    const auto& likes_col = tracks_df.get_column<int>("likes");
    const auto& clicks_col = tracks_df.get_column<int>("clicks");
    const auto& full_listens_col = tracks_df.get_column<int>("full_listens");
    const auto& author_ids_col = tracks_df.get_column<std::string>("author_id");
    const auto& names_col = authors_df.get_column<std::string>("name");
    const auto& author_listeners_col = authors_df.get_column<int>("author_listeners");
    const auto& genres_col = authors_df.get_column<std::string>("genre");
    
    for (size_t i = 0; i < track_ids_col.size(); ++i) {
        std::cout << track_ids_col[i] << "      | "
                  << titles_col[i] << " | "
                  << likes_col[i] << "   | "
                  << clicks_col[i] << "   | "
                  << full_listens_col[i] << "          | "
                  << author_ids_col[i] << "      | "
                  << names_col[i] << " | "
                  << author_listeners_col[i] << "             | "
                  << genres_col[i] << std::endl;
    }

This code prints out a merged view of the data, combining track and author information side by side.

Output:

text

Merged Data:
Track ID | Title  | Likes | Clicks | Full Listens | Author ID | Name      | Author Listeners | Genre
---------|--------|-------|--------|--------------|-----------|-----------|------------------|------
001      | Song A | 150   | 300    | 120          | A1        | Artist X  | 5000             | Rock
002      | Song B | 200   | 400    | 180          | A2        | Artist Y  | 8000             | Pop
003      | Song C | 100   | 250    | 95           | A3        | Artist Z  | 3000             | Jazz

Merged Data:
Track ID | Title  | Likes | Clicks | Full Listens | Author ID | Name      | Author Listeners | Genre
---------|--------|-------|--------|--------------|-----------|-----------|------------------|------
001      | Song A | 150   | 300    | 120          | A1        | Artist X  | 5000             | Rock
002      | Song B | 200   | 400    | 180          | A2        | Artist Y  | 8000             | Pop
003      | Song C | 100   | 250    | 95           | A3        | Artist Z  | 3000             | Jazz

Extracting Relevant Content Features

Content features are specific attributes of data that can be used to calculate recommendations. They provide the basis for comparing items and identifying similarities.

In our example, we’re interested in features such as the number of likes, clicks, full_listens, the number of author_listeners, and the genre. We can access and display these columns directly:

C++

    // Display the content features by accessing columns directly
    std::cout << "\nFinal Content Features DataFrame:" << std::endl;
    std::cout << "Track ID | Likes | Clicks | Full Listens | Author Listeners | Genre" << std::endl;
    std::cout << "---------|-------|--------|--------------|------------------|------" << std::endl;
    
    for (size_t i = 0; i < track_ids_col.size(); ++i) {
        std::cout << track_ids_col[i] << "      | " 
                  << likes_col[i] << "   | " 
                  << clicks_col[i] << "   | " 
                  << full_listens_col[i] << "          | " 
                  << author_listeners_col[i] << "             | " 
                  << genres_col[i] << std::endl;
    }

    // Display the content features by accessing columns directly
    std::cout << "\nFinal Content Features DataFrame:" << std::endl;
    std::cout << "Track ID | Likes | Clicks | Full Listens | Author Listeners | Genre" << std::endl;
    std::cout << "---------|-------|--------|--------------|------------------|------" << std::endl;
    
    for (size_t i = 0; i < track_ids_col.size(); ++i) {
        std::cout << track_ids_col[i] << "      | " 
                  << likes_col[i] << "   | " 
                  << clicks_col[i] << "   | " 
                  << full_listens_col[i] << "          | " 
                  << author_listeners_col[i] << "             | " 
                  << genres_col[i] << std::endl;
    }

This results in a clean table with only the essential features that drive our recommendation logic.