I tried to implement this keras code into pytorch https://keras.io/examples/structured_data/collaborative_filtering_movielens/ . While training this code does not converge and the training loss also increases
import sys
import pandas as pd
import torch
import numpy as np
import torch.nn as nn
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
import torch.nn.functional as F
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
dataset = pd.read_csv("ml-latest-small/ratings.csv")
user_ids = dataset['userId'].unique().tolist()
print(len(user_ids))
user2user_encoded = {x: i for i, x in enumerate(user_ids)}
user_encoded2user = {i: x for i, x in enumerate(user_ids)}
movie_ids = dataset["movieId"].unique().tolist()
movie2movie_encoded = {x: i for i, x in enumerate(movie_ids)}
movie_encoded2movie = {i: x for i, x in enumerate(movie_ids)}
dataset["user"] = dataset["userId"].map(user2user_encoded)
dataset["movie"] = dataset["movieId"].map(movie2movie_encoded)
num_users = len(user2user_encoded)
num_movies = len(movie_encoded2movie)
dataset["rating"] = dataset["rating"].values.astype(np.float64)
min_rating = min(dataset["rating"])
max_rating = max(dataset["rating"])
print(
"Number of users: {}, Number of movies: {}, Min rating: {}, Max rating: {}".format(
num_users,
num_movies,
min_rating,
max_rating))
#########################################
# Prepare Training and Validation data
dataset = dataset.sample(frac=1)
x = dataset[["user", "movie"]].values
y = dataset["rating"].apply(lambda x: (
x - min_rating) / (max_rating - min_rating)).values
train_indices = int(0.9 * dataset.shape[0])
x_train, x_val, y_train, y_val = (
x[:train_indices], x[train_indices:], y[:train_indices], y[train_indices:])
print(type(x_train))
x_train=torch.from_numpy(x_train)
y_train=torch.from_numpy(y_train).float()
x_val=torch.from_numpy(x_val)
y_val=torch.from_numpy(y_val).float()
class DatasetColab(Dataset):
def __init__(self, x, y):
self.x = x
self.y = y
def __len__(self):
return len(self.x)
def __getitem__(self, index):
X = self.x[index]
Y = self.y[index]
return X, Y
training_set = DatasetColab(x_train, y_train)
val_set = DatasetColab(x_val, y_val)
training_loader = DataLoader(training_set, batch_size=64, shuffle=True)
val_loader = DataLoader(val_set, batch_size=64, shuffle=False)
###########################################
# Creating the PyTorch model
class RecommenderNet(nn.Module):
def __init__(self, num_users, num_movies, embedding_size):
super(RecommenderNet, self).__init__()
self.num_users = num_users
self.num_movies = num_movies
self.embedding_size = embedding_size
self.user_embedding = nn.Embedding(num_users, embedding_size)
self.user_bias = nn.Embedding(num_users, 1)
self.movie_embedding = nn.Embedding(num_movies, embedding_size)
self.movie_bias = nn.Embedding(num_movies, 1)
self.sigmoid=nn.Sigmoid()
def forward(self, inputs):
user_vector = self.user_embedding(inputs[:, 0])
user_bias = self.user_bias(inputs[:, 0])
movie_vector = self.movie_embedding(inputs[:, 1])
movie_bias = self.movie_bias(inputs[:, 1])
dot_user_movie = torch.tensordot(user_vector, movie_vector, 2)
x = dot_user_movie + user_bias + movie_bias
x = self.sigmoid(x)
return x
EMBEDDING_SIZE = 50
model = RecommenderNet(num_users, num_movies, EMBEDDING_SIZE)
model = model.to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=0.001, eps=1e-7, weight_decay=1e-6)
def compute_val_loss(net, data_loader):
net.eval()
cost_val=0
with torch.no_grad():
for features, targets in data_loader:
features=features.to(device)
targets=targets.unsqueeze(1)
targets=targets.to(device)
logits=net(features)
cost_val+=F.binary_cross_entropy(logits, targets)
return cost_val/1000
num_epochs = 20
loss=nn.BCELoss()
for epoch in range(num_epochs):
cost_train=0
model.train()
for idx, (features, targets) in enumerate(training_loader):
features = features.to(device)
#targets=targets.unsqueeze(1)
targets = targets.to(device)
optimizer.zero_grad()
# Forward and Back propagation
preds = model(features)
cost = loss(preds, targets)
cost_train+=cost
# Update model parameters
cost.backward()
optimizer.step()
print("Epoch: {}/{} || Train Loss: {} || Val Loss: {}".format(epoch+1, num_epochs, cost_train/1000, compute_val_loss(model, val_loader)))
I would appreciate any help as to where am I implementing it wrong.