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.

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:

// tracks.json
[
    {
        "track_id": "001",
        "title": "Song A",
        "likes": 150,
        "clicks": 300,
        "full_listens": 120,
        "author_id": "A1"
    },
    {
        "track_id": "002",
        "title": "Song B",
        "likes": 200,
        "clicks": 400,
        "full_listens": 180,
        "author_id": "A2"
    },
    {
        "track_id": "003",
        "title": "Song C",
        "likes": 100,
        "clicks": 250,
        "full_listens": 95,
        "author_id": "A3"
    }
]

// authors.json
[
    {
        "author_id": "A1",
        "name": "Artist X",
        "author_listeners": 5000,
        "genre": "Rock"
    },
    {
        "author_id": "A2",
        "name": "Artist Y",
        "author_listeners": 8000,
        "genre": "Pop"
    },
    {
        "author_id": "A3",
        "name": "Artist Z",
        "author_listeners": 3000,
        "genre": "Jazz"
    }
]

Note that we link a track to its author using the author_id field.

Instead of working with plain JavaScript arrays, we will use Danfo.js DataFrames (dfd.DataFrame) for efficient data manipulation, similar to how data is handled in Python's pandas library.

Here’s how you can load and represent the datasets as DataFrames:

import { readFile } from 'fs/promises';
import dfd from 'danfojs-node';

// Load data from JSON files
const tracksData = JSON.parse(await readFile('tracks.json', 'utf-8'));
const authorsData = JSON.parse(await readFile('authors.json', 'utf-8'));

const tracks_df = new dfd.DataFrame(tracksData);
const authors_df = new dfd.DataFrame(authorsData);

After loading, the DataFrames tracks_df and authors_df look like this:

tracks_df:

  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:

  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.

To make meaningful recommendations, we need to combine information about tracks and authors. This process is called merging, and it helps us create a unified view of the data.

With Danfo.js, we can merge the tracks_df and authors_df DataFrames by matching the author_id field. Here’s how you can do this:

function mergeTracksAndAuthors(tracks_df, authors_df) {
    // Merge the dataframes on the common 'author_id' field
    return dfd.merge({
        left: tracks_df,
        right: authors_df,
        on: ['author_id'],
        how: 'inner'
    });
}

// Complete merge operation
const merged_df = mergeTracksAndAuthors(tracks_df, authors_df);

// Display the merged dataset
merged_df.print();

The merged_df will look like this:

  track_id   title   likes   clicks   full_listens   author_id   name      author_listeners   genre
0  001       Song A  150     300      120            A1         Artist X  5000               Rock
1  002       Song B  200     400      180            A2         Artist Y  8000               Pop
2  003       Song C  100     250      95             A3         Artist Z  3000               Jazz

This code merges the DataFrames so that each track is paired with the corresponding author information. Only tracks with a matching author are included.

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. Let’s select these columns from the merged DataFrame:

// Select relevant content features
const contentFeatures = ["likes", "clicks", "full_listens", "author_listeners", "genre"];
const contentFeatures_df = merged_df.loc({ columns: contentFeatures });

contentFeatures_df.print();

Output:

   likes   clicks   full_listens   author_listeners   genre
0  150     300      120            5000               Rock
1  200     400      180            8000               Pop
2  100     250      95             3000               Jazz

This output shows a clean DataFrame with only the essential features that drive our recommendation logic.

Note: The genre feature is categorical (text), unlike the other numeric features. Before we can use it in similarity calculations or modeling, we will need to transform it—typically by one-hot encoding or another suitable encoding method. We will cover this transformation in a later lesson.

In this lesson, we've covered the initial steps in building a content-based recommendation system using Danfo.js DataFrames. Starting from loading the data, merging datasets, and extracting relevant content features, you've gained skills crucial for moving forward with more comprehensive recommendations.

The next step for you is to apply this knowledge in practice exercises on CodeSignal, where you will put into practice what you've just learned. Remember, the skills acquired here are foundational, paving the way for more sophisticated and personalized recommendation systems. Keep exploring, and enjoy the process of crafting tailored experiences for your future users!