Chapter 19: Recommendation Systems with Deep Learning

Bloom's Taxonomy Map for This Chapter

Learning Objectives

By the end of this chapter, you will be able to:

• Define collaborative filtering, content-based filtering, and hybrid recommendation systems, and explain when each paradigm is most suitable
• Derive the matrix factorization objective with regularization and implement gradient descent updates for user/item latent factor matrices
• Explain how Neural Collaborative Filtering (NCF) generalises matrix factorization by replacing the dot product with a learned neural network
• Implement embedding layers in PyTorch and TensorFlow to represent users and items as dense, low-dimensional vectors
• Describe the two-tower architecture (user tower + item tower) and explain how approximate nearest neighbour search enables real-time retrieval at scale
• Reproduce the key components of the YouTube recommendation DNN (2016 paper) — candidate generation and ranking stages
• Build a from-scratch matrix factorization model using NumPy and a Neural CF model using TensorFlow/Keras on the MovieLens dataset
• Analyze recommendation fairness issues — urban vs. rural bias, language bias, and cold-start problems for new sellers on Indian platforms
• Evaluate recommendation quality using metrics like RMSE, Precision@K, Recall@K, NDCG, and Hit Rate
• Design a hybrid deep learning recommendation system for an Indian e-commerce or OTT streaming scenario

Opening Hook

Core Concepts

We'll build up from the simplest approaches to state-of-the-art deep learning architectures. The roadmap: Classical CF → Matrix Factorization → Neural CF → Content-Based DL → Hybrid → Two-Tower → YouTube DNN → Fairness.

PyTorch
import torch
import torch.nn as nn

# Embedding: maps integer IDs → dense vectors
user_embedding = nn.Embedding(
    num_embeddings=500000,  # 5 lakh users
    embedding_dim=64        # each user → 64-dim vector
)

item_embedding = nn.Embedding(
    num_embeddings=100000,  # 1 lakh items
    embedding_dim=64
)

# Usage
user_id = torch.tensor([42])
item_id = torch.tensor([1337])

user_vec = user_embedding(user_id)   # shape: (1, 64)
item_vec = item_embedding(item_id)   # shape: (1, 64)

# Dot product → predicted score
score = torch.sum(user_vec * item_vec, dim=1)
print(f"Predicted score: {score.item():.4f}")

TensorFlow
import tensorflow as tf

# TensorFlow Embedding layer
user_embedding = tf.keras.layers.Embedding(
    input_dim=500000,    # vocabulary size
    output_dim=64,       # embedding dimension
    name="user_embedding"
)

item_embedding = tf.keras.layers.Embedding(
    input_dim=100000,
    output_dim=64,
    name="item_embedding"
)

# Lookup
user_vec = user_embedding(tf.constant([42]))     # (1, 64)
item_vec = item_embedding(tf.constant([1337]))   # (1, 64)

# Cosine similarity
score = tf.keras.losses.cosine_similarity(user_vec, item_vec)

From-Scratch Code

4A. Matrix Factorization with Gradient Descent (NumPy)

We'll implement biased matrix factorization from scratch using SGD on a Bollywood movie ratings dataset.

Python
import numpy as np

class MatrixFactorization:
    """
    Biased Matrix Factorization with SGD
    r̂_ui = μ + b_u + b_i + p_u · q_i
    
    Bollywood Movie Recommendation from Scratch
    """
    
    def __init__(self, n_users, n_items, n_factors=50, lr=0.005,
                 reg=0.02, n_epochs=20, random_state=42):
        self.n_users = n_users
        self.n_items = n_items
        self.n_factors = n_factors
        self.lr = lr
        self.reg = reg
        self.n_epochs = n_epochs
        
        np.random.seed(random_state)
        
        # Initialize latent factor matrices (small random values)
        self.P = np.random.normal(0, 0.1, (n_users, n_factors))  # User factors
        self.Q = np.random.normal(0, 0.1, (n_items, n_factors))  # Item factors
        
        # Bias terms
        self.b_u = np.zeros(n_users)  # User bias
        self.b_i = np.zeros(n_items)  # Item bias
        self.mu = 0                    # Global mean
    
    def fit(self, ratings):
        """
        Train on list of (user_id, item_id, rating) tuples.
        
        Parameters:
        -----------
        ratings : list of tuples [(u, i, r), ...]
            u = user index, i = item index, r = rating (1-5)
        """
        # Compute global mean
        self.mu = np.mean([r for _, _, r in ratings])
        
        training_loss = []
        
        for epoch in range(self.n_epochs):
            # Shuffle training data each epoch
            np.random.shuffle(ratings)
            total_loss = 0
            
            for u, i, r in ratings:
                # Predict: r̂ = μ + b_u + b_i + p_u · q_i
                pred = self.mu + self.b_u[u] + self.b_i[i] + \
                       np.dot(self.P[u], self.Q[i])
                
                # Compute error
                error = r - pred
                total_loss += error ** 2
                
                # Update biases
                self.b_u[u] += self.lr * (error - self.reg * self.b_u[u])
                self.b_i[i] += self.lr * (error - self.reg * self.b_i[i])
                
                # Update latent factors
                # p_u ← p_u + α(e_ui · q_i − λ · p_u)
                P_old = self.P[u].copy()
                self.P[u] += self.lr * (error * self.Q[i] - self.reg * self.P[u])
                self.Q[i] += self.lr * (error * P_old - self.reg * self.Q[i])
            
            # Add regularization to loss
            reg_loss = self.reg * (
                np.sum(self.P ** 2) + np.sum(self.Q ** 2) +
                np.sum(self.b_u ** 2) + np.sum(self.b_i ** 2)
            )
            rmse = np.sqrt(total_loss / len(ratings))
            training_loss.append(rmse)
            
            if (epoch + 1) % 5 == 0:
                print(f"Epoch {epoch+1:3d}/{self.n_epochs} | "
                      f"RMSE: {rmse:.4f} | Reg Loss: {reg_loss:.2f}")
        
        return training_loss
    
    def predict(self, user_id, item_id):
        """Predict rating for a (user, item) pair."""
        pred = self.mu + self.b_u[user_id] + self.b_i[item_id] + \
               np.dot(self.P[user_id], self.Q[item_id])
        # Clip to valid rating range
        return np.clip(pred, 1.0, 5.0)
    
    def recommend(self, user_id, n=10, exclude_rated=None):
        """Return top-n item recommendations for a user."""
        scores = []
        for i in range(self.n_items):
            if exclude_rated and i in exclude_rated:
                continue
            scores.append((i, self.predict(user_id, i)))
        
        # Sort by predicted rating, descending
        scores.sort(key=lambda x: x[1], reverse=True)
        return scores[:n]


# ─── Demo: Bollywood Movie Ratings ───
# Movie mapping (index → name)
movies = {
    0: "Dangal",       1: "3 Idiots",     2: "KGF",
    3: "Bahubali",     4: "Pushpa",       5: "DDLJ",
    6: "PK",           7: "Zindagi NMDD", 8: "RRR",
    9: "Kantara",      10: "Lagaan",      11: "Drishyam",
}

users = {0: "Priya", 1: "Rahul", 2: "Aisha", 3: "Vikram",
         4: "Neha",  5: "Arjun", 6: "Meera", 7: "Karthik"}

# Simulated ratings: (user_id, item_id, rating)
ratings = [
    (0,0,5), (0,1,4), (0,3,3), (0,5,5), (0,10,4),
    (1,1,5), (1,2,4), (1,4,3), (1,8,5), (1,9,4),
    (2,0,4), (2,2,5), (2,3,4), (2,8,4), (2,9,5),
    (3,1,3), (3,3,5), (3,4,4), (3,8,5), (3,11,4),
    (4,0,3), (4,2,4), (4,5,5), (4,6,4), (4,7,5),
    (5,2,5), (5,3,4), (5,4,5), (5,8,5), (5,9,4),
    (6,0,4), (6,5,5), (6,6,5), (6,7,4), (6,10,5),
    (7,2,4), (7,3,5), (7,9,5), (7,11,3),
]

# Train the model
mf = MatrixFactorization(n_users=8, n_items=12, n_factors=10,
                          lr=0.01, reg=0.02, n_epochs=50)
losses = mf.fit(ratings)

# Get recommendations for Priya (user 0)
# Exclude movies she has already rated
priya_rated = {0, 1, 3, 5, 10}
recs = mf.recommend(0, n=5, exclude_rated=priya_rated)

print("\n🎬 Top 5 Recommendations for Priya:")
for item_id, score in recs:
    print(f"  {movies[item_id]:<15s} → Predicted Rating: {score:.2f}")

Notice how Priya — who rated DDLJ (5), Dangal (5), 3 Idiots (4), and Lagaan (4) — gets recommended PK and Zindagi NMDD. This makes sense: she's a fan of Aamir Khan and feel-good Bollywood films. The latent factors have captured this pattern!

4B. Neural Collaborative Filtering from Scratch (NumPy)

Python
import numpy as np

class NeuralCFScratch:
    """
    Simple Neural CF implemented with NumPy.
    Architecture: User Emb + Item Emb → Concat → Dense(64) → ReLU → Dense(32) → ReLU → Dense(1) → Sigmoid
    For binary implicit feedback (clicked/not-clicked).
    """
    
    def __init__(self, n_users, n_items, emb_dim=32, lr=0.001):
        self.n_users = n_users
        self.n_items = n_items
        self.emb_dim = emb_dim
        self.lr = lr
        
        # Initialize embeddings
        scale = 0.01
        self.user_emb = np.random.randn(n_users, emb_dim) * scale
        self.item_emb = np.random.randn(n_items, emb_dim) * scale
        
        # Layer 1: (2 * emb_dim) → 64
        self.W1 = np.random.randn(2 * emb_dim, 64) * np.sqrt(2.0 / (2 * emb_dim))
        self.b1 = np.zeros(64)
        
        # Layer 2: 64 → 32
        self.W2 = np.random.randn(64, 32) * np.sqrt(2.0 / 64)
        self.b2 = np.zeros(32)
        
        # Output layer: 32 → 1
        self.W3 = np.random.randn(32, 1) * np.sqrt(2.0 / 32)
        self.b3 = np.zeros(1)
    
    def relu(self, x):
        return np.maximum(0, x)
    
    def relu_grad(self, x):
        return (x > 0).astype(np.float64)
    
    def sigmoid(self, x):
        return 1.0 / (1.0 + np.exp(-np.clip(x, -500, 500)))
    
    def forward(self, user_id, item_id):
        """Forward pass through the network."""
        # Get embeddings
        self.p = self.user_emb[user_id]   # (emb_dim,)
        self.q = self.item_emb[item_id]   # (emb_dim,)
        
        # Concatenate
        self.x0 = np.concatenate([self.p, self.q])  # (2*emb_dim,)
        
        # Layer 1
        self.z1 = self.x0 @ self.W1 + self.b1       # (64,)
        self.a1 = self.relu(self.z1)                 # (64,)
        
        # Layer 2
        self.z2 = self.a1 @ self.W2 + self.b2        # (32,)
        self.a2 = self.relu(self.z2)                 # (32,)
        
        # Output
        self.z3 = self.a2 @ self.W3 + self.b3        # (1,)
        self.y_hat = self.sigmoid(self.z3)           # (1,)
        
        return self.y_hat[0]
    
    def backward(self, user_id, item_id, y_true):
        """Backward pass + parameter updates."""
        # Binary cross-entropy gradient at output
        dz3 = (self.y_hat - y_true)  # (1,) — sigmoid + BCE simplifies!
        
        # Output layer gradients
        dW3 = self.a2.reshape(-1, 1) @ dz3.reshape(1, -1)
        db3 = dz3
        
        # Layer 2 gradients
        da2 = (dz3 @ self.W3.T).flatten()
        dz2 = da2 * self.relu_grad(self.z2)
        dW2 = self.a1.reshape(-1, 1) @ dz2.reshape(1, -1)
        db2 = dz2
        
        # Layer 1 gradients
        da1 = (dz2 @ self.W2.T).flatten()
        dz1 = da1 * self.relu_grad(self.z1)
        dW1 = self.x0.reshape(-1, 1) @ dz1.reshape(1, -1)
        db1 = dz1
        
        # Embedding gradients
        dx0 = (dz1 @ self.W1.T).flatten()
        dp = dx0[:self.emb_dim]
        dq = dx0[self.emb_dim:]
        
        # Update parameters (SGD)
        self.W3 -= self.lr * dW3
        self.b3 -= self.lr * db3
        self.W2 -= self.lr * dW2
        self.b2 -= self.lr * db2
        self.W1 -= self.lr * dW1
        self.b1 -= self.lr * db1
        self.user_emb[user_id] -= self.lr * dp
        self.item_emb[item_id] -= self.lr * dq
    
    def train(self, data, n_epochs=20):
        """
        Train on implicit feedback data.
        data: list of (user_id, item_id, label)  where label ∈ {0, 1}
        """
        for epoch in range(n_epochs):
            np.random.shuffle(data)
            total_loss = 0
            for u, i, y in data:
                y_hat = self.forward(u, i)
                # Binary cross-entropy loss
                loss = -(y * np.log(y_hat + 1e-8) +
                         (1 - y) * np.log(1 - y_hat + 1e-8))
                total_loss += loss
                self.backward(u, i, y)
            
            if (epoch + 1) % 5 == 0:
                avg_loss = total_loss / len(data)
                print(f"Epoch {epoch+1:3d} | BCE Loss: {avg_loss:.4f}")

# ─── Demo ───
ncf = NeuralCFScratch(n_users=8, n_items=12, emb_dim=16, lr=0.005)

# Convert explicit ratings to implicit: rating ≥ 4 → positive (1)
implicit_data = [(u, i, 1) for u, i, r in ratings if r >= 4]
# Add negative samples (random unrated items)
rated_pairs = {(u, i) for u, i, _ in ratings}
for _ in range(len(implicit_data)):
    u = np.random.randint(8)
    i = np.random.randint(12)
    if (u, i) not in rated_pairs:
        implicit_data.append((u, i, 0))

ncf.train(implicit_data, n_epochs=30)

Industry Code — Neural CF with TensorFlow/Keras

5A. NeuMF Model (TensorFlow)

TensorFlow
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import numpy as np
import pandas as pd

# ─── Load MovieLens 100K Dataset ───
# Download from: https://grouplens.org/datasets/movielens/100k/
# For this demo, we use the built-in format

url = "https://files.grouplens.org/datasets/movielens/ml-100k/u.data"
columns = ["user_id", "item_id", "rating", "timestamp"]
df = pd.read_csv(url, sep="\t", names=columns)

# Re-index to 0-based
df["user_id"] = df["user_id"] - 1
df["item_id"] = df["item_id"] - 1

n_users = df["user_id"].nunique()
n_items = df["item_id"].nunique()
print(f"Users: {n_users}, Items: {n_items}, Ratings: {len(df)}")

# Convert to implicit: rating ≥ 4 → 1, else 0
df["label"] = (df["rating"] >= 4).astype(np.float32)

# Train/test split by timestamp (temporal split — more realistic)
df = df.sort_values("timestamp")
split_idx = int(len(df) * 0.8)
train_df = df.iloc[:split_idx]
test_df = df.iloc[split_idx:]

# ─── Build NeuMF Model ───
def build_neumf(n_users, n_items, emb_dim=64, mlp_layers=[128, 64, 32]):
    """
    Neural Matrix Factorization (NeuMF) combining:
    - GMF path (element-wise product of embeddings)
    - MLP path (concatenation through FC layers)
    """
    # Input
    user_input = layers.Input(shape=(1,), name="user_input")
    item_input = layers.Input(shape=(1,), name="item_input")
    
    # ── GMF Path ──
    gmf_user_emb = layers.Embedding(n_users, emb_dim,
                                     name="gmf_user_emb")(user_input)
    gmf_item_emb = layers.Embedding(n_items, emb_dim,
                                     name="gmf_item_emb")(item_input)
    gmf_user_emb = layers.Flatten()(gmf_user_emb)
    gmf_item_emb = layers.Flatten()(gmf_item_emb)
    
    # Element-wise product (Generalized MF)
    gmf_output = layers.Multiply()([gmf_user_emb, gmf_item_emb])
    
    # ── MLP Path ──
    mlp_user_emb = layers.Embedding(n_users, emb_dim,
                                     name="mlp_user_emb")(user_input)
    mlp_item_emb = layers.Embedding(n_items, emb_dim,
                                     name="mlp_item_emb")(item_input)
    mlp_user_emb = layers.Flatten()(mlp_user_emb)
    mlp_item_emb = layers.Flatten()(mlp_item_emb)
    
    # Concatenate and pass through MLP
    mlp_concat = layers.Concatenate()([mlp_user_emb, mlp_item_emb])
    
    x = mlp_concat
    for units in mlp_layers:
        x = layers.Dense(units, activation="relu")(x)
        x = layers.Dropout(0.2)(x)
    mlp_output = x
    
    # ── Combine GMF + MLP ──
    combined = layers.Concatenate()([gmf_output, mlp_output])
    
    # Final prediction
    output = layers.Dense(1, activation="sigmoid",
                          name="prediction")(combined)
    
    model = keras.Model(inputs=[user_input, item_input], outputs=output)
    return model

# Build and compile
model = build_neumf(n_users, n_items, emb_dim=64)
model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=0.001),
    loss="binary_crossentropy",
    metrics=["accuracy", keras.metrics.AUC(name="auc")]
)

model.summary()

# ─── Train ───
history = model.fit(
    [train_df["user_id"].values, train_df["item_id"].values],
    train_df["label"].values,
    batch_size=256,
    epochs=10,
    validation_data=(
        [test_df["user_id"].values, test_df["item_id"].values],
        test_df["label"].values
    ),
    verbose=1
)

# ─── Evaluate ───
test_loss, test_acc, test_auc = model.evaluate(
    [test_df["user_id"].values, test_df["item_id"].values],
    test_df["label"].values
)
print(f"\nTest Accuracy: {test_acc:.4f}")
print(f"Test AUC: {test_auc:.4f}")

5B. Two-Tower Model for Bollywood Movie Retrieval

TensorFlow
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

def build_two_tower(n_users, n_items, n_genres=20,
                     n_languages=12, emb_dim=32, tower_dim=64):
    """
    Two-Tower Retrieval Model for Indian OTT platform.
    User tower: user_id + preferred_language
    Item tower: item_id + genre + language
    """
    
    # ── USER TOWER ──
    user_id_input = layers.Input(shape=(1,), name="user_id")
    user_lang_input = layers.Input(shape=(1,), name="user_lang")
    
    user_emb = layers.Embedding(n_users, emb_dim)(user_id_input)
    user_emb = layers.Flatten()(user_emb)
    user_lang = layers.Embedding(n_languages, 8)(user_lang_input)
    user_lang = layers.Flatten()(user_lang)
    
    user_concat = layers.Concatenate()([user_emb, user_lang])
    user_vec = layers.Dense(tower_dim, activation="relu")(user_concat)
    user_vec = layers.Dense(tower_dim, activation=None)(user_vec)
    # L2 normalize for cosine similarity
    user_vec = tf.nn.l2_normalize(user_vec, axis=1)
    
    # ── ITEM TOWER ──
    item_id_input = layers.Input(shape=(1,), name="item_id")
    genre_input = layers.Input(shape=(1,), name="genre")
    item_lang_input = layers.Input(shape=(1,), name="item_lang")
    
    item_emb = layers.Embedding(n_items, emb_dim)(item_id_input)
    item_emb = layers.Flatten()(item_emb)
    genre_emb = layers.Embedding(n_genres, 8)(genre_input)
    genre_emb = layers.Flatten()(genre_emb)
    item_lang = layers.Embedding(n_languages, 8)(item_lang_input)
    item_lang = layers.Flatten()(item_lang)
    
    item_concat = layers.Concatenate()([item_emb, genre_emb, item_lang])
    item_vec = layers.Dense(tower_dim, activation="relu")(item_concat)
    item_vec = layers.Dense(tower_dim, activation=None)(item_vec)
    item_vec = tf.nn.l2_normalize(item_vec, axis=1)
    
    # ── Dot product similarity ──
    similarity = layers.Dot(axes=1)([user_vec, item_vec])
    output = layers.Activation("sigmoid")(similarity)
    
    model = keras.Model(
        inputs=[user_id_input, user_lang_input,
                item_id_input, genre_input, item_lang_input],
        outputs=output
    )
    return model

# Build
two_tower = build_two_tower(
    n_users=100000, n_items=50000,
    n_genres=20, n_languages=12
)
two_tower.compile(
    optimizer="adam",
    loss="binary_crossentropy",
    metrics=["accuracy"]
)
two_tower.summary()

print("\n✅ Two-Tower model ready!")
print("User tower output: 64-d normalized vector")
print("Item tower output: 64-d normalized vector")
print("At serving: pre-compute item vectors → FAISS index")
print("Real-time: compute user vector → ANN search → top-K")

5C. Recommendation Evaluation Metrics

Python
import numpy as np

def precision_at_k(recommended, relevant, k):
    """
    Precision@K: Of the top-K recommended, how many are relevant?
    
    Example: Recommended top-5 for Priya: [Dangal, KGF, PK, DDLJ, Pushpa]
             Relevant (actually liked):    {Dangal, DDLJ, 3 Idiots}
             Precision@5 = 2/5 = 0.40
    """
    rec_k = recommended[:k]
    hits = len(set(rec_k) & set(relevant))
    return hits / k

def recall_at_k(recommended, relevant, k):
    """Recall@K: Of all relevant items, how many appear in top-K?"""
    rec_k = recommended[:k]
    hits = len(set(rec_k) & set(relevant))
    return hits / len(relevant) if relevant else 0

def ndcg_at_k(recommended, relevant, k):
    """
    Normalized Discounted Cumulative Gain @ K.
    Rewards relevant items appearing higher in the ranking.
    
    DCG@K  = Σ(i=1 to K) rel_i / log2(i+1)
    IDCG@K = DCG of perfect ranking
    NDCG   = DCG / IDCG
    """
    dcg = 0.0
    for i, item in enumerate(recommended[:k]):
        if item in relevant:
            dcg += 1.0 / np.log2(i + 2)  # +2 because i is 0-indexed
    
    # Ideal DCG: all relevant items at top
    ideal_hits = min(len(relevant), k)
    idcg = sum(1.0 / np.log2(i + 2) for i in range(ideal_hits))
    
    return dcg / idcg if idcg > 0 else 0

def hit_rate_at_k(recommended, relevant, k):
    """Hit Rate: Is there at least one relevant item in top-K?"""
    return 1.0 if len(set(recommended[:k]) & set(relevant)) > 0 else 0.0

# ─── Demo ───
recommended = ["Dangal", "KGF", "PK", "DDLJ", "Pushpa",
               "RRR", "3 Idiots", "Lagaan", "Kantara", "Bahubali"]
relevant = {"Dangal", "DDLJ", "3 Idiots", "Lagaan"}

for k in [3, 5, 10]:
    print(f"K={k:2d} | P@K={precision_at_k(recommended, relevant, k):.3f} | "
          f"R@K={recall_at_k(recommended, relevant, k):.3f} | "
          f"NDCG@K={ndcg_at_k(recommended, relevant, k):.3f} | "
          f"Hit={hit_rate_at_k(recommended, relevant, k):.0f}")

Visual Diagrams

6.1 Evolution of Recommendation Systems

6.2 Matrix Factorization — Geometric View

6.3 NeuMF Architecture (Detailed)

6.4 Two-Tower Serving Architecture

Worked Example

Matrix Factorization: Step-by-Step Hand Calculation

Setup: 3 users, 4 Bollywood movies, latent dimension k = 2.

Step 1: The Rating Matrix

Step 2: Initialize Latent Factors (k=2)

Step 3: Predict r̂(Priya, Dangal)

Step 4: Compute Error

Step 5: Update Parameters (α = 0.01, λ = 0.02)

Step 6: Predict Missing — r̂(Priya, KGF)

After training converges (many epochs), suppose we get:

Interpretation: The model predicts Priya would rate KGF at 5.0 (maximum). Looking at her preferences — she liked Dangal (5) and 3 Idiots (4) — she appreciates well-made blockbusters. KGF fits this pattern. Note how the latent factors captured this without explicit genre matching!

Case Study — Amazon India: Deep Learning Recommendations & the Cold-Start Challenge

Common Mistakes & Misconceptions

Comparison Table

10.1 Recommendation Approaches Compared

10.2 Evaluation Metrics Compared

Exercises

Chapter Summary

References

Foundational Papers

1. Koren, Y., Bell, R., & Volinsky, C. (2009). Matrix Factorization Techniques for Recommender Systems. IEEE Computer, 42(8), 30–37. [The definitive Netflix Prize paper on MF]
2. He, X., Liao, L., Zhang, H., Nie, L., Hu, X., & Chua, T.S. (2017). Neural Collaborative Filtering. WWW 2017. [NCF/NeuMF architecture]
3. Covington, P., Adams, J., & Sargin, E. (2016). Deep Neural Networks for YouTube Recommendations. RecSys 2016. [The YouTube DNN paper — most influential industrial RecSys paper]
4. Cheng, H.T., et al. (2016). Wide & Deep Learning for Recommender Systems. DLRS 2016. [Google's Wide & Deep architecture]
5. Yi, X., et al. (2019). Sampling-Bias-Corrected Neural Modeling for Large Corpus Item Recommendations. RecSys 2019. [Google's two-tower with in-batch negatives]

Advanced / Modern

6. Sun, F., et al. (2019). BERT4Rec: Sequential Recommendation with Bidirectional Encoder Representations from Transformers. CIKM 2019.
7. Rendle, S. (2010). Factorization Machines. ICDM 2010. [Generalisation of MF for feature-rich settings]
8. Wang, R., et al. (2017). Deep & Cross Network for Ad Click Predictions. ADKDD 2017.
9. Johnson, J., Douze, M., & Jégou, H. (2019). Billion-Scale Similarity Search with GPUs. IEEE TPAMI. [FAISS for ANN search]

Indian Context & Fairness

10. Mehta, B., & Hofmann, T. (2008). A Survey of Attack-Resistant Collaborative Filtering Algorithms. ACM Computing Surveys.
11. Singh, A., & Joachims, T. (2018). Fairness of Exposure in Rankings. KDD 2018. [Fairness-aware ranking algorithms]
12. ONDC Documentation (2023). Open Network for Digital Commerce — Algorithm Transparency Guidelines. Government of India.
13. Amazon India Engineering Blog (2022). Scaling Recommendations for 300M+ Users with Two-Tower Models.
14. Flipkart Tech Blog (2021). Building Real-Time Personalisation at Scale: From MF to Deep Retrieval.

Textbooks

15. Aggarwal, C.C. (2016). Recommender Systems: The Textbook. Springer. [Comprehensive reference]
16. Ricci, F., Rokach, L., & Shapira, B. (2015). Recommender Systems Handbook. 2nd Edition, Springer.
17. Goodfellow, I., Bengio, Y., & Courville, A. (2016). Deep Learning. MIT Press. [Chapter 15 on representation learning]

Datasets

18. GroupLens Research. MovieLens Datasets. Available at: https://grouplens.org/datasets/movielens/
19. Amazon Product Reviews Dataset. Jianmo Ni, UCSD. Available at: https://nijianmo.github.io/amazon/
20. Last.fm Dataset (for music recommendation research).