5 mins Recommender systems: Neural Collaborative Filtering | by Omar Tafsi | Jun, 2024

As you’ll have seen, Matrix Factorization could also be merely generalized and extended through the NFC framework by altering the MLP half with a simple dot-product block that takes as enter the patron and merchandise embeddings and outputs their ingredient smart product.

import numpy as np
import tensorflow as tf
from sklearn.model_selection import train_test_split
from tensorflow.keras.layers import Enter, Embedding, Flatten, Concatenate, Dense
from tensorflow.keras.fashions import Model
from tensorflow.keras.optimizers import Adam
from sklearn.metrics import mean_absolute_error
class NeuralCF:
def __init__(self, num_users, num_items, embedding_dim=10, hidden_layers=[64, 32], activation='relu', learning_rate=0.001):
self.num_users = num_users
self.num_items = num_items
self.embedding_dim = embedding_dim
self.hidden_layers = hidden_layers
self.activation = activation
self.learning_rate = learning_rate
def _build_model(self):
user_input = Enter(kind=(1,))
item_input = Enter(kind=(1,))
user_embedding = Embedding(self.num_users, self.embedding_dim)(user_input)
user_embedding = Flatten()(user_embedding)
item_embedding = Embedding(self.num_items, self.embedding_dim)(item_input)
item_embedding = Flatten()(item_embedding)
vector = Concatenate()([user_embedding, item_embedding])
for fashions in self.hidden_layers:
vector = Dense(fashions, activation=self.activation)(vector)
output = Dense(1, activation='sigmoid')(vector)
model = Model(inputs=[user_input, item_input], outputs=output)
return model
def put together(self, X_train, y_train, epochs=10, batch_size=10, validation_split=0.1):
X_train = [X_train[:, 0], X_train[:, 1]]
y_train = np.array(y_train)
model = self._build_model()
model.compile(optimizer=Adam(learning_rate=self.learning_rate), loss="mean_squared_error")
model.match(X_train, y_train, epochs=epochs, batch_size=batch_size, validation_split=validation_split)
self.model = model
def predict(self, X_test):
X_test = [X_test[:, 0], X_test[:, 1]]
return self.model.predict(X_test)
# Hyperparameters that may be tuned
embedding_dim = 10
hidden_layers = [64, 32]
activation = 'relu'
learning_rate = 0.001
# we choose a subset of the netflix rating dataset found proper right here : https://www.kaggle.com/datasets/rishitjavia/netflix-movie-rating-dataset?select=Netflix_Dataset_Rating.csv
df = pd.read_csv("/content material materials/Netflix_Dataset_Rating.csv").iloc[:1000,:]
X = df[['User_ID','Movie_ID']].to_numpy()
y = df['Rating'].to_numpy()
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
num_users = df['User_ID'].max() + 1
num_items = df['Movie_ID'].max() + 1
# Put together and predict using NeuralCF
ncf = NeuralCF(num_users, num_items, embedding_dim, hidden_layers, activation, learning_rate)
ncf.put together(X_train, y_train)
y_pred = ncf.predict(X_test)
# Contemplate using Suggest Squared Error
mse = mean_absolute_error(y_test, y_pred)
print("Suggest Absolute Error:", mse)

As a reminder, we’re planning in order so as to add a loyal article submit the place we study how all the RS methods we’ve launched by testing each one in opposition to an enormous dataset to measure various teaching and serving metrics (MAP@Okay, time to teach, time to infer, ease of integrating new prospects/objects, ease of parallelization. and plenty of others)

This family of fashions brings new important recommender system properties that are the following:

1. Non-Linearity: Not like standard collaborative filtering methods like matrix factorization, NCFs make use of neural networks, allowing it to grab non-linear relationships between prospects and objects. This allows the NCF to model superior user-item interactions further exactly, foremost to raised suggestion effectivity.
2. Flexibility: NCFs present flexibility in modeling quite a few varieties of data and interactions. The construction of NCF could also be custom-made with various layers and completely totally different activation options, providing flexibility in capturing quite a few patterns in client conduct and preferences.
3. Scalability: Neural networks are extraordinarily scalable and will take care of large-scale datasets successfully. NCFs can course of big portions of user-item interactions and be taught from implicit solutions, making it applicable for real-world suggestion applications deployed in large-scale on-line platforms. Moreover, developments in {{hardware}} and distributed computing extra enhance the scalability of NCF fashions, letting them serve tens of thousands and thousands of consumers and objects with low latency

Now, let’s speak in regards to the three largest shortcomings of the Neural Collaborative Filtering approach:

1. Chilly Start Draw back: Like many suggestion applications, NCF struggles with the chilly start draw back, the place it’s troublesome to provide right solutions for model new prospects or objects with restricted interaction information. Since NCF will depend on historic interactions between prospects and objects to make predictions, it may not perform correctly when there’s insufficient information for model new entities.
2. Data Sparsity: In real-world conditions, user-item interaction information is normally sparse, which means that almost all prospects have solely interacted with a small subset of issues. This information sparsity may end up in challenges in finding out right client and merchandise embeddings, most likely resulting in suboptimal solutions.
3. Interpretability and Transparency: NCF fashions are typically seen as “black containers,” which means their inside workings are normally not merely interpretable. This lack of transparency could also be problematic for understanding why positive solutions are made, which is crucial for perception and client satisfaction. This problem limits the flexibleness to provide explanations for solutions, which is increasingly important for client perception and regulatory compliance (e.g., GDPR). It moreover makes it extra sturdy for builders to diagnose and improve model effectivity efficiently.

These shortcomings highlight the need for ongoing evaluation and enchancment to deal with the challenges associated to collaborative filtering methods like NCF.

As a result of the digital panorama continues to evolve, the demand for personalised suggestion applications will solely develop. On this context, NCF emerges as a groundbreaking technique, reshaping the easiest way we perceive collaborative filtering and unlocking new prospects for delivering tailored solutions to prospects worldwide. With its functionality to be taught from raw information and seize superior user-item interactions, NCFs are a strong performer inside the topic of recommendation applications.