Creating a Recommender System with PyTorch for Collaborative Filtering

Recommender systems are widely used in e-commerce, social media, and other platforms to provide personalized recommendations to users based on their preferences and behavior. In this tutorial, we will learn how to build a recommender system using PyTorch with collaborative filtering.

Collaborative filtering is a common approach to building recommender systems that leverages the behavior of users and items to make recommendations. It can be further divided into two types: user-based collaborative filtering and item-based collaborative filtering. In this tutorial, we will focus on user-based collaborative filtering.

To build a user-based collaborative filtering recommender system, we will use the MovieLens dataset, which contains movie ratings from users. We will use PyTorch to implement the collaborative filtering algorithm and train a model to make movie recommendations to users.

Step 1: Loading the Data
First, we need to load the MovieLens dataset into a Pandas DataFrame. You can download the dataset from here: https://grouplens.org/datasets/movielens/latest/. Make sure to download the ml-latest-small.zip file.

import pandas as pd

# Load the ratings data
ratings = pd.read_csv('ml-latest-small/ratings.csv')

# Display the first few rows of the ratings data
print(ratings.head())

Step 2: Preparing the Data
Next, we need to prepare the data for training the model. We will create a user-item matrix where rows represent users, columns represent items (movies), and values represent ratings.

# Create a user-item matrix
user_item_matrix = ratings.pivot(index='userId', columns='movieId', values='rating').fillna(0)

Step 3: Building the Model
Now, we will define a collaborative filtering model using PyTorch. We will use a simple matrix factorization model with embedding layers for users and items.

import torch
import torch.nn as nn
import torch.optim as optim

class CollaborativeFiltering(nn.Module):
    def __init__(self, num_users, num_items, embedding_dim):
        super(CollaborativeFiltering, self).__init__()
        self.user_embedding = nn.Embedding(num_users, embedding_dim)
        self.item_embedding = nn.Embedding(num_items, embedding_dim)

    def forward(self, user_ids, item_ids):
        user_embeds = self.user_embedding(user_ids)
        item_embeds = self.item_embedding(item_ids)
        return torch.sum(user_embeds * item_embeds, dim=1)

Step 4: Training the Model
Now, we will train the collaborative filtering model using the user-item matrix we created earlier. We will use PyTorch’s DataLoader class to create batches of data for training.

from torch.utils.data import DataLoader, TensorDataset

# Convert the user-item matrix to PyTorch tensors
user_ids = torch.LongTensor(user_item_matrix.index.values)
item_ids = torch.LongTensor(user_item_matrix.columns.values)
ratings = torch.FloatTensor(user_item_matrix.values)

# Create a DataLoader for training
dataset = TensorDataset(user_ids, item_ids, ratings)
dataloader = DataLoader(dataset, batch_size=64, shuffle=True)

# Initialize the model and optimizer
model = CollaborativeFiltering(num_users=len(user_item_matrix), num_items=len(user_item_matrix.columns), embedding_dim=50)
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Train the model
for epoch in range(10):
    for user_ids_batch, item_ids_batch, ratings_batch in dataloader:
        ratings_pred = model(user_ids_batch, item_ids_batch)
        loss = nn.MSELoss()(ratings_pred, ratings_batch)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    print(f'Epoch {epoch+1}, Loss: {loss.item()}')

Step 5: Making Recommendations
Finally, we can make movie recommendations to users using the trained model. We will get the embeddings of users and items and compute the dot product to get the predicted ratings for all movies. We can then recommend the top N movies with the highest predicted ratings.

user_embeddings = model.user_embedding.weight.detach()
item_embeddings = model.item_embedding.weight.detach()

def recommend_movies(user_id, top_n=10):
    user_embed = user_embeddings[user_id]
    ratings_pred = torch.matmul(user_embed, item_embeddings.T)
    top_indices = ratings_pred.argsort(descending=True)[:top_n]
    top_movie_ids = item_ids[top_indices].numpy()
    top_movies = ratings.columns[top_movie_ids].tolist()
    return top_movies

# Make recommendations for user 100
print(recommend_movies(100))

That’s it! In this tutorial, we learned how to build a collaborative filtering recommender system using PyTorch. Collaborative filtering is a powerful technique for making personalized recommendations, and PyTorch makes it easy to implement and train models for recommendation systems. Feel free to experiment with different hyperparameters, model architectures, and datasets to improve the performance of your recommender system.