Neural Collaborative Filtering

Most recommendation research before 2017 focused on explicit feedback — star ratings, thumbs up/down. But in practice, implicit feedback dominates: clicks, views, purchases, time spent. The problem is that implicit feedback only tells you what a user did interact with. A zero doesn't mean dislike — it could mean the user never saw the item. There are no real negatives, only observed positives and a sea of unknowns.

The standard approach was matrix factorization: represent each user as a vector $\mathbf{p}_u$ and each item as a vector $\mathbf{q}_i$, then predict interaction as their inner product $\hat{y}_{ui} = \mathbf{p}_u^T \mathbf{q}_i$. This was popularized by the Netflix Prize and refined by BPR (Bayesian Personalized Ranking) for implicit feedback.

Matrix factorization's inner product is a linear combination of latent dimensions — each dimension is independent and contributes equally. This limits its expressiveness. Consider the paper's famous example: four users with interaction patterns that cannot be faithfully represented in a low-dimensional space using inner products alone.

User $u_4$ is most similar to $u_1$, then $u_3$, then $u_2$. But once you have placed $u_1$, $u_2$, and $u_3$ in the latent space, there is no position for $u_4$ that preserves all three rankings simultaneously. The inner product creates a geometry too rigid for real interaction patterns — it's like trying to draw a map of friendships on a flat piece of paper when the real relationships are tangled in many dimensions.

The key insight of NCF is deceptively simple: replace the fixed inner product with a neural network that learns the interaction function from data. Instead of assuming that user-item compatibility is a dot product, let the network discover any function — linear or nonlinear — that best predicts interactions.

The framework works in four stages. First, the user ID and item ID are converted to one-hot vectors. Second, an embedding layer projects these sparse vectors into dense latent vectors. Third, the embeddings are fed into neural collaborative filtering layers — this is where the magic happens and where different model variants differ. Fourth, the output layer produces a predicted score between 0 and 1.

NCF is a framework, not a single model. The paper proposes three instantiations that differ in how they combine the user and item embeddings:

GMF (Generalized Matrix Factorization) takes the element-wise product of the user and item embedding vectors, then passes the result through a weighted output layer with a sigmoid activation. When the output weights are all ones and there is no activation, GMF reduces exactly to standard MF. But the learnable weights allow each latent dimension to contribute differently — some dimensions matter more than others.

MLP (Multi-Layer Perceptron) concatenates the user and item embeddings into a single vector and passes it through multiple dense layers with ReLU activations. Each layer progressively distills higher-order interaction patterns. The tower architecture (e.g., 64→32→16→8) gradually narrows, compressing complex interactions into a compact prediction signal.

NeuMF (Neural Matrix Factorization) is the fusion: run GMF and MLP in parallel with separate embedding sets, concatenate their last hidden layers, and feed the combined vector through a final prediction layer. This lets the model capture both the linearity of MF and the nonlinearity of deep networks simultaneously.

The first NCF instantiation recovers classical MF and then generalizes it. The idea is elegant: compute the element-wise product of user and item embeddings (which is what MF does inside the inner product), but instead of summing all dimensions equally, pass the product through a learnable output layer.

The MLP path takes a fundamentally different approach. Instead of multiplying embeddings element-wise, it concatenates them into a single vector and feeds it through a tower of dense layers. Each layer applies a linear transformation followed by a ReLU activation. Think of it as a conversation between the user representation and the item representation — each layer allows them to interact in increasingly abstract ways.

The tower architecture shrinks progressively. If the predictive factors are 8, the MLP layers might be 32→16→8 with an embedding size of 16 on each side. This bottleneck forces the network to distill the most predictive interaction patterns.

NeuMF is the paper's flagship model. It runs GMF and MLP in parallel, each with its own set of embeddings. This is crucial — sharing embeddings would force both paths to use the same representation, limiting the model. Separate embeddings let GMF learn the linear patterns it's good at while MLP focuses on nonlinear patterns.

The last hidden layers of both paths are concatenated and fed into a single output neuron with sigmoid activation. A hyperparameter α controls the trade-off between the two paths during pre-training initialization.

A key design choice in NCF is treating the recommendation task as binary classification rather than regression. For each observed interaction $(u, i)$, the label is 1. For unobserved pairs, items are randomly sampled as negative examples with label 0. The number of negative samples per positive instance is a tunable ratio — the paper found that 3–6 negatives per positive works well.

The loss function is binary cross-entropy (log loss), which naturally fits the probabilistic interpretation: the model outputs the probability that user $u$ will interact with item $i$. This is more principled than squared error for binary targets, because it penalizes confident wrong predictions much more heavily.

Training NeuMF from random initialization can be tricky because the model is non-convex and has many local minima. The paper's solution: pre-train GMF and MLP separately using Adam optimizer, then use their learned parameters to initialize NeuMF. Only the output weights of the fused model are initialized from scratch — specifically as a weighted combination controlled by α (set to 0.5 for equal contribution).

After initialization, NeuMF is fine-tuned with vanilla SGD rather than Adam. The reasoning: Adam maintains momentum information that would be mismatched with the pre-trained parameters from a different optimization trajectory. This two-stage training — pre-train components, then fine-tune the whole — became a common pattern in later recommendation models.

The paper evaluated on two datasets: MovieLens 1M (1 million ratings from 6,000 users on 4,000 movies, binarized to implicit feedback) and Pinterest (1.5 million interactions from 55,000 users on 9,900 images, naturally implicit). The evaluation metric was Hit Rate and NDCG at top-K, using leave-one-out evaluation.

The results were clear and consistent: NeuMF outperformed all baselines on both datasets. The performance ranking was always NeuMF > MLP > GMF > BPR > eALS > ItemKNN. Deeper MLP architectures improved performance, confirming that adding nonlinear layers helps. The negative sampling ratio mattered — too few negatives (1 per positive) degraded performance, while 3–6 negatives struck the right balance.

Perhaps most importantly, the pre-training strategy consistently improved NeuMF over random initialization, validating the two-stage training approach.

NCF's insight — that the interaction function should be learned — was simple, but it redirected an entire field. Every major recommendation model since 2017, from DIN to BERT4Rec, builds on this foundation.