Recommender systems are crucial for personalizing user experiences across various platforms. These systems predict and suggest items that users are likely to interact with, based on their past behavior and preferences. Building an effective recommender system involves leveraging large, complex datasets that capture user-item interactions.

Recommender Systems and Co-Visitation Matrices

Recommender systems are machine learning algorithms designed to deliver personalized suggestions to users. They are widely used in e-commerce, content streaming, and social media to help users discover products, services, or content aligned with their interests.

Datasets for recommender systems typically include:

• Items to recommend, which can number in the millions.
• Interactions between users and items, forming sessions that help infer future user interactions.

A co-visitation matrix counts items that appear together in a session, making it easier to recommend items that frequently co-occur with those in a user’s session.

Challenges in Building Co-Visitation Matrices

Computing co-visitation matrices involves processing numerous sessions and counting all co-occurrences, which can be computationally expensive. Traditional methods using libraries like pandas can be inefficient and slow for large datasets, necessitating heavy optimization for practical use.

RAPIDS cuDF, a GPU DataFrame library, addresses these issues by providing a pandas-like API for faster data manipulation. It accelerates computations by up to 40x without requiring code changes.

RAPIDS cuDF Pandas Accelerator Mode

RAPIDS cuDF is designed to speed up operations like loading, joining, aggregating, and filtering on large datasets. Its new pandas accelerator mode allows for accelerated computing in pandas workflows, delivering 50x to 150x faster performance for tabular data processing.

The Data

The data for this tutorial comes from the OTTO – Multi-Objective Recommender System Kaggle competition, which includes one month of sessions. The dataset contains 1.86 million items and around 500 million user-item interactions, stored in chunked parquet files for easier handling.

Implementing Co-Visitation Matrices

To build co-visitation matrices efficiently, the data is split into parts to manage memory usage. Sessions are loaded, and transformations are applied to save memory. Interactions are restricted to a manageable number, and co-occurrences are computed by merging the data with itself on the session column.

Weights are assigned to pairs of items, and the matrix is updated by adding new weights to previous ones. Finally, the matrix is reduced to keep only the best candidates per item, ensuring that the most relevant information is retained.

Generating Candidates

Co-visitation matrices can be used to generate recommendation candidates by aggregating weights over session items. The items with the highest weights are recommended. This process benefits significantly from the GPU accelerator, making it faster and more efficient.

Performance Assessment

The recall metric is used to evaluate the strength of the candidates. In this case, the recall@20 metric showed a strong baseline performance, with an achieved recall of 0.5868. This means that out of 20 items recommended, on average, 11 were purchased by the user.

Going Further

Improving candidate recall involves giving more history to the matrices, refining the matrices by considering interaction types, and adjusting weights based on the importance of session items. These changes can significantly enhance the performance of recommender systems.

Summary

This tutorial demonstrates how to build and optimize co-visitation matrices using RAPIDS cuDF. Leveraging GPU acceleration, co-visitation matrix computation becomes up to 50x faster, enabling quick iterations and improvements in recommender systems.

For more details, visit the NVIDIA Technical Blog.

Image source: Shutterstock