Overview of Recommender Systems (RecSys)

---

Part 1: End-to-End System Foundations & Pipeline Architecture

Modern industrial recommendation engines process item catalogs ranging from millions to billions of candidates in real time. To serve personalized results under tight latency constraints (typically $< 100 \text{ ms}$), production architectures adopt a multi-stage funnel pattern.

+-----------------------------------------------------------------------+
|                         Catalog (10^6 - 10^9 Items)                   |
+-----------------------------------------------------------------------+
                                    |
                                    v
+-----------------------------------------------------------------------+
|  Stage 1: Candidate Generation / Retrieval (Latency: 10-20 ms)         |
|  - High Recall, Low Complexity                                        |
|  - Algorithms: Collaborative Filtering, Two-Tower, ANN, Vector Search  |
|  -> Reduces pool to: ~10^2 - 10^3 Candidates                          |
+-----------------------------------------------------------------------+
                                    |
                                    v
+-----------------------------------------------------------------------+
|  Stage 2: Ranking / Scoring (Latency: 30-50 ms)                       |
|  - High Precision, Complex Deep Learning Models                       |
|  - Algorithms: Wide & Deep, DCN-v2, DLRM, Multi-Task Neural Nets      |
|  -> Output: Scored & Ranked List (~50 - 200 Candidates)                |
+-----------------------------------------------------------------------+
                                    |
                                    v
+-----------------------------------------------------------------------+
|  Stage 3: Re-ranking & Business Logic (Latency: 5-10 ms)             |
|  - Constraints: Diversity, Freshness, Fair Distribution, Deduplication|
|  - Multi-Objective Optimization (MOO), Multi-Armed Bandits (MAB)      |
|  -> Output: Top-K Filtered Set (~10 - 50 Items)                       |
+-----------------------------------------------------------------------+
                                    |
                                    v
+-----------------------------------------------------------------------+
|  Stage 4: Score Calibration & Page Generation (Latency: 5-10 ms)      |
|  - Probabilistic Alignment (Platt Scaling, Isotonic Regression)       |
|  - Layout Optimization, Slate Generation, Moderation Filters          |
|  -> Final User-Facing Slate / Feed                                    |
+-----------------------------------------------------------------------+

Stage Responsibilities and Trade-Offs

Funnel Stage	Input Pool	Output Pool	Primary Objective	Key Compute Bottleneck	Model Complexity
Candidate Generation	$10^6 - 10^9$	$10^2 - 10^3$	Maximize Recall	Vector Index Query / Sublinear Search	Low to Medium
Ranking	$10^2 - 10^3$	$50 - 200$	Maximize Precision / Engagement (CTR, Conversion)	Deep Neural Network Forward Pass / Cross-Features	High
Re-ranking	$50 - 200$	$10 - 50$	Optimize Diversity, Novelty, Business Constraints	Dynamic Rules & Multi-Objective Pareto Optimization	Medium
Calibration	$10 - 50$	Top-K Slate	Align raw model scores with true click/conversion probabilities	Univariate function evaluation / Monotonic mapping	Low

---

Part 2: Candidate Generation & Retrieval Systems

The retrieval stage narrows down millions of items to hundreds of relevant candidates.

Mathematical Notation & Formulation

Let $U$ be the set of users and $I$ be the set of items. The interaction matrix $R \in \mathbb{R}^{\vert{}U\vert{} \times \vert{}I\vert{}}$ contains observed interactions $r_{ui}$ (explicit ratings or implicit actions like clicks and views).

Content-Based Filtering

Computes user profile representations $\mathbf{u} \in \mathbb{R}^d$ and item feature vectors $\mathbf{v}_i \in \mathbb{R}^d$ from metadata (text embeddings, genres, categories). Similarity is evaluated via cosine similarity:

\[\text{Sim}(u, i) = \frac{\mathbf{u} \cdot \mathbf{v}_i}{\Vert{}\mathbf{u}\Vert{}_2 \Vert{}\mathbf{v}_i\Vert{}_2}\]

• Advantages: Solves item cold-start for new items with rich metadata; highly interpretable.
• Limitations: Overspecialization (“filter bubble”); cannot capture serendipitous preferences.

Collaborative Filtering (CF)

Relies on historical user-item interactions without requiring explicit domain metadata.

Matrix Factorization (MF)

Decomposes the interaction matrix $R$ into lower-rank user embeddings $P \in \mathbb{R}^{\vert{}U\vert{} \times k}$ and item embeddings $Q \in \mathbb{R}^{\vert{}I\vert{} \times k}$, where $k \ll \min(\vert{}U\vert{}, \vert{}I\vert{})$:

\[\hat{r}_{ui} = \mathbf{p}_u^T \mathbf{q}_i\]

Objective function with L2 regularization:

\[\min_{P, Q} \sum_{(u, i) \in \mathcal{K}} \left( r_{ui} - \mathbf{p}_u^T \mathbf{q}_i \right)^2 + \lambda \left( \Vert{}\mathbf{p}_u\Vert{}_2^2 + \Vert{}\mathbf{q}_i\Vert{}_2^2 \right)\]

Alternating Least Squares (ALS) for Implicit Feedback

For implicit datasets (clicks, watches, reads), preference $p_{ui}$ and confidence $c_{ui}$ are defined as:

\[p_{ui} = \begin{cases} 1 & r_{ui} > 0 \\ 0 & r_{ui} = 0 \end{cases}, \quad c_{ui} = 1 + \alpha r_{ui}\]

The cost function is minimized by alternating between updating user vectors $\mathbf{p}_u$ and item vectors $\mathbf{q}_i$:

\[\mathbf{p}_u = \left( Q^T C^u Q + \lambda I \right)^{-1} Q^T C^u p_u\]

Two-Tower Neural Retrieval Architectures

Two-Tower models use separate neural subnetworks to project user context and candidate metadata into a shared embedding space $\mathbb{R}^d$.

User Context Features                            Candidate Item Features
(User ID, Search Query,                          (Item ID, Category, Text,
 Recent History, Location)                        Image Vectors, Tags)
           |                                                |
           v                                                v
+-----------------------+                        +-----------------------+
|   User Tower (MLP)    |                        |  Item Tower (MLP)     |
+-----------------------+                        +-----------------------+
           |                                                |
           v                                                v
    User Vector u in R^d                             Item Vector v in R^d
           \                                                /
            \                                              /
             +--------------------> Dot Product <---------+
                                        |
                                        v
                            s(u, v) = u^T v  (Cosine / Inner Product)

Loss Formulation: Sampled Softmax with In-Batch Negatives

For a batch of $B$ positive pairs ${(u_j, v_j)}_{j=1}^B$, the in-batch cross-entropy loss with logQ correction for item frequency sampling bias is:

\[\mathcal{L} = -\frac{1}{B} \sum_{j=1}^B \log \frac{\exp\left(s(u_j, v_j) - \log P(v_j)\right)}{\sum_{k=1}^B \exp\left(s(u_j, v_k) - \log P(v_k)\right)}\]

Where $P(v_k)$ is the estimated sampling probability of candidate $v_k$.

---

Part 3: Deep Neural Network Ranking Architectures

The ranking stage scores candidate items using complex non-linear feature interactions.

                           +------------------------+
                           |     Output (CTR/pCTR)  |
                           +------------------------+
                                        ^
                                        |
                   +--------------------+--------------------+
                   |                                         |
        +--------------------+                    +--------------------+
        |  Explicit Cross    |                    |  Deep MLP Layers   |
        |  Network / Field   |                    |  (Non-linear       |
        |  Interactions      |                    |   Transformations) |
        +--------------------+                    +--------------------+
                   ^                                         ^
                   |                                         |
                   +--------------------+--------------------+
                                        |
                          +--------------------------+
                          |   Concatenated Dense     |
                          |   & Sparse Embeddings    |
                          +--------------------------+

Architecture Comparison Matrix

Architecture	Interaction Explicit/Implicit	Order of Feature Crosses	Sparse Embedding Handling	Best suited for
Wide & Deep	Combination (Explicit Wide + Implicit Deep)	1st Order (Wide) + High-order (MLP)	Manual Cross-Product Transformations	CTR Prediction with Memorization + Generalization
Deep & Cross (DCN)	Explicit & Implicit	Arbitrary degree $L$ (bounded by cross layers)	Shared Embeddings	Automatic feature interactions without manual engineering
DCN-v2	Explicit Matrix Cross + Implicit	Degree $L$ with Matrix-Vector multiplications	Low-rank tensor decomposition	Large-scale production CTR models
NCF (Neural CF)	Implicit	Arbitrary non-linear interaction via GMF + MLP	Sparse User & Item One-hot IDs	Matrix Factorization generalization
DeepFM	Explicit & Implicit	1st, 2nd Order (FM) + High-order (MLP)	Dual sharing of embedding vectors between FM & Deep	Replacing manual feature engineering
AutoInt	Explicit Self-Attention	Multi-head attention interactions	Sparse categorical features	Interpretable multi-order feature interaction
DLRM	Explicit Pairwise Dot Product	2nd Order explicit + High-order MLP	Large embedding tables with model parallel processing	E-commerce / Ad click systems

Deep & Cross Network (DCN & DCN-v2)

DCN introduces explicit cross networks that apply feature crossing at each layer.

DCN-v1 Cross Layer Formulation:

\[\mathbf{x}_{l+1} = \mathbf{x}_0 \mathbf{x}_l^T \mathbf{w}_l + \mathbf{b}_l + \mathbf{x}_l\]

DCN-v2 Matrix Cross Layer Formulation:

\[\mathbf{x}_{l+1} = \mathbf{x}_0 \odot \left( W_l \mathbf{x}_l + \mathbf{b}_l \right) + \mathbf{x}_l\]

Where $W_l \in \mathbb{R}^{d \times d}$ is parameter-wise factorized into low-rank matrices $U_l \in \mathbb{R}^{d \times r}$ and $V_l \in \mathbb{R}^{r \times d}$ ($r \ll d$) to reduce hardware memory footprints.

Deep Learning Recommendation Model (DLRM)

DLRM computes explicit 2nd-order feature interactions by computing dot products between all embedding pairs, then concatenating the output with dense features processed by a Bottom MLP, passing the unified tensor to a Top MLP.

       +-----------------------+
       |       Top MLP         |
       +-----------------------+
                   ^
                   |
    +--------------+--------------+
    |                             |
[Dot Product Cross Interacts]   [Bottom MLP Output (Dense)]
    ^
    |
[Sparse Embeddings (E1, E2, ...)]

---

Part 4: Learning to Rank (LTR) & Scoring Mechanisms

Learning to Rank formulates recommendation scoring as an optimization problem across ordered item lists.

LTR Approaches

+------------------+----------------------------------+------------------------------------+
| Paradigm         | Input Data Unit                  | Loss Optimization Target           |
+------------------+----------------------------------+------------------------------------+
| Pointwise        | Single Item (u, i)               | Individual Item CTR / Binary CE    |
| Pairwise         | Item Pair (u, i, j) where i > j  | Relative Preference Order / Margin |
| Listwise         | Full Ranked List (u, i_1...i_k)  | List-level Metrics (NDCG, MAP)     |
+------------------+----------------------------------+------------------------------------+

Pairwise Ranking: RankNet & LambdaRank

RankNet

RankNet models the posterior probability that item $i$ is preferred over item $j$ using a sigmoid model on raw network scores $s_i = f(x_i)$ and $s_j = f(x_j)$:

\[P_{ij} = P(i \succ j) = \frac{1}{1 + \exp\left(-(s_i - s_j)\right)}\]

The pairwise cross-entropy loss for target label $\bar{P}_{ij} \in {0, 1}$ is:

\[\mathcal{L}_{ij} = -\bar{P}_{ij} \log P_{ij} - (1 - \bar{P}_{ij}) \log (1 - P_{ij})\]

LambdaRank

LambdaRank speeds up training by defining implicit gradients $\lambda_{ij}$ scaled by the change in target ranking metrics ($\Delta \text{NDCG}$):

\[\lambda_{ij} = \frac{\partial \mathcal{L}_{ij}}{\partial(s_i - s_j)} = \frac{-1}{1 + \exp(s_i - s_j)} \vert{}\Delta \text{NDCG}\vert{}\]

Objective Functions & Loss Formulations

Bayesian Personalized Ranking (BPR) Loss

Designed for implicit feedback datasets where user $u$ interacted with $i$ ($i \in I_u^+$) and not $j$ ($j \notin I_u^+$):

\[\mathcal{L}_{\text{BPR}} = -\sum_{u \in U} \sum_{i \in I_u^+} \sum_{j \notin I_u^+} \log \sigma \left( \hat{x}_{ui} - \hat{x}_{uj} \right) + \lambda_{\Theta} \Vert{}\Theta\Vert{}^2\]

---

Part 5: Multi-Objective Optimization (MOO) & Post-Processing

Real-world recommendation systems balance competing business metrics (e.g., Clicks, Watch Time, Likes, Shares, Conversions).

Multi-Objective Formulations

\[\max_{\mathbf{x}} \mathbf{f}(\mathbf{x}) = \left[ f_{\text{click}}(\mathbf{x}), f_{\text{watch time}}(\mathbf{x}), f_{\text{share}}(\mathbf{x}) \right]^T\]

Scalarization Methods

Combines objectives linearly using scalar weights $\mathbf{w}$:

\[S(u, i) = w_1 \cdot \hat{p}_{\text{click}} + w_2 \cdot \hat{y}_{\text{dwell time}} + w_3 \cdot \hat{p}_{\text{conversion}}\]

Pareto Efficiency in Re-ranking

Item $i$ Pareto-dominates item $j$ if $f_k(i) \ge f_k(j)$ for all objectives $k$, and there exists at least one objective $m$ where $f_m(i) > f_m(j)$. The re-ranker selects items from the Pareto-optimal frontier.

Re-ranking Dynamics

Ranked Candidates ---> [ Diversity Engine (DPP / Maximal Marginal Relevance) ]
                             |
                             v
                       [ Freshness & Decay Filter ]
                             |
                             v
                       [ Fairness & Popularity Regularizer ]
                             |
                             v
                       Final Slate Output

Diversity via Maximal Marginal Relevance (MMR)

MMR greedily balances item relevance $S(u, i)$ against similarity to already selected candidates $R$:

\[\text{MMR} = \arg\max_{i \in C \setminus R} \left[ \lambda S(u, i) - (1 - \lambda) \max_{j \in R} \text{Sim}(i, j) \right]\]

Freshness & Time Decay

Adjusts raw scoring using exponential time decay functions:

\[S_{\text{fresh}}(i, t) = S_{\text{raw}}(i) \cdot \exp\left( -\gamma (t - t_{\text{publish}})^k \right)\]

Score Calibration

Raw outputs $s(x)$ from complex classification models often fail to represent true posterior probabilities. Calibration maps raw scores to accurate probabilities $P(y=1 \mid s)$.

Method	Mathematical Formulation	Pros	Cons
Platt Scaling	$P(y=1 \mid s) = \frac{1}{1 + \exp(A \cdot s + B)}$	Simple, parametric, fast optimization	Assumes sigmoid shape; poor fit for non-sigmoidal error distributions
Isotonic Regression	$\min \sum \left( y_i - \hat{y}_i \right)^2 \quad \text{s.t.} \quad \hat{y}_i \le \hat{y}_j \text{ if } s_i \le s_j$	Non-parametric, flexible monotonic curve fitting	Susceptible to overfitting on small validation datasets
Bayesian Binning (BBQ)	$P(y=1 \mid s) = \sum_{m} P(y=1 \mid s, M_m) P(M_m \mid D)$	Robust uncertainty handling, prevents overfitting	High compute complexity; hyperparameter sensitive

---

Part 6: Graph Neural Networks & Sequential Transformers in RecSys

Graph models and sequential Transformers capture complex graph structures and short-term user intent.

Graph Neural Networks (GNNs)

Recommender interactions form bipartite graphs $\mathcal{G} = (\mathcal{U}, \mathcal{V}, \mathcal{E})$ between user nodes $\mathcal{U}$ and item nodes $\mathcal{V}$.

User Nodes (U)             Item Nodes (V)
   ( u1 ) -------------------- ( i1 )
      \                       /  |
       \                     /   |
        \                   /    |
         ---> ( u2 ) ------      ( i2 )

GraphSAGE Neighborhood Aggregation

Aggregates representations from localized $k$-hop topological neighborhoods:

\[\mathbf{h}_{N(v)}^{(k)} = \text{AGGREGATE}_k \left( \mathbf{h}_u^{(k-1)}, \forall u \in N(v) \right)\] \[\mathbf{h}_v^{(k)} = \sigma \left( W^{(k)} \cdot \text{CONCAT} \left( \mathbf{h}_v^{(k-1)}, \mathbf{h}_{N(v)}^{(k)} \right) \right)\]

PinSage (Pinterest Industrial GNN)

PinSage uses random walks to construct dynamic localized neighborhoods, running graph convolutions over the highest-visitation nodes to generate embeddings for billions of items.

Transformers & Sequential Recommendation

Recurrent models like GRUs process user history linearly, whereas Transformers model explicit sequence dependencies in parallel using attention mechanisms.

Behavioral Sequence Transformer (BST)

BST passes historical interaction item embeddings along with target candidate item embeddings through Transformer encoder blocks:

\[\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{Q K^T}{\sqrt{d_k}}\right) V\]

Position encodings incorporate temporal intervals between actions:

\[t(v_i) = t_{\text{current}} - t_{\text{action i}}\]

---

Part 7: Search Systems, Exploration & Bandit Algorithms

Search and recommendation systems share similar retrieval and scoring infrastructures.

Search Paradigms in RecSys

+-------------------+--------------------------------+-------------------------------------+
| Paradigm          | Core Mechanism                 | Key Limitations                     |
+-------------------+--------------------------------+-------------------------------------+
| Lexical Search    | Sparse matching (BM25, TF-IDF) | Vocabulary mismatch; missing semantic context |
| Semantic Search   | Dense vector search (ANN, HNSW)| Query latency; compute overhead     |
| Hybrid Search     | Reciprocal Rank Fusion (RRF)   | Score normalization across domains  |
+-------------------+--------------------------------+-------------------------------------+

Hybrid Fusion via Reciprocal Rank Fusion (RRF):

\[RRF_{\text{score}}(d \in D) = \sum_{m \in M} \frac{1}{k + r_m(d)}\]

Where $r_m(d)$ is the rank of document $d$ in retrieval system $m$, and $k$ is a smoothing constant (typically $k=60$).

Multi-Armed Bandit (MAB) Algorithms

Bandit models balance exploration of under-sampled candidates against exploitation of high-performing items.

               +----------------------------------+
               | Select Arm (Action) based on     |
               | Exploration/Exploitation Policy |
               +----------------------------------+
                                |
                                v
               +----------------------------------+
               | Observe User Reward (Click/Buy)  |
               +----------------------------------+
                                |
                                v
               +----------------------------------+
               | Update Value Distribution / UCB  |
               +----------------------------------+

$\epsilon$-Greedy

Selects a random item with probability $\epsilon$, and selects the item with the highest expected reward $\hat{Q}(a)$ with probability $1 - \epsilon$.

Upper Confidence Bound (UCB1)

Selects arms according to potential upper confidence intervals:

\[a_t = \arg\max_a \left[ \hat{Q}_t(a) + c \sqrt{\frac{\ln t}{N_t(a)}} \right]\]

Where $N_t(a)$ is the selection count of arm $a$ up to time step $t$.

Thompson Sampling

Models expected reward parameters using posterior Beta distributions $\text{Beta}(\alpha_a, \beta_a)$:

1. Draw sample $\theta_a \sim \text{Beta}(\alpha_a, \beta_a)$ for each candidate arm $a$.
2. Recommend candidate $a^* = \arg\max_a \theta_a$.
3. Update parameters upon interaction: $\alpha_{a^*} \leftarrow \alpha_{a^*} + r$, $\beta_{a^*} \leftarrow \beta_{a^*} + (1-r)$.

---

Part 8: Large Language Models (LLMs) in Recommender Systems

Large Language Models enhance recommender systems through zero-shot reasoning, semantic understanding, and unified sequence generation.

+---------------------------------------------------------------------------------+
|                       LLM Recommender Paradigm Integration                      |
+---------------------------------------------------------------------------------+
| 1. LLM as Feature Extractor: Text/Item -> LLM Embeddings -> Conventional RecSys |
| 2. LLM as Scoring Reranker: Prompt (User History + Candidates) -> LLM -> Ranked List
| 3. Generative RecSys: Tokenized Semantic IDs -> LLM Decoder -> Next Item Tokens|
+---------------------------------------------------------------------------------+

Generative Recommendation via Semantic IDs

Instead of using randomly initialized index lookup tables for item IDs, items are mapped to semantic IDs generated via hierarchical vector quantization (e.g., RQ-VAE).

Item Metadata/Image ---> [ RQ-VAE Encoder ] ---> Codebook Quantization 
                                                        |
                                                        v
                                          Semantic ID Tuple: (3, 42, 118, 9)

The recommendation task is formulated as auto-regressive next-token prediction:

\[P(I_t \mid I_1, I_2, \dots, I_{t-1}) = \prod_{k=1}^L P\left(c_t^k \mid I_{< t}, c_t^{< k}\right)\]

Where $(c_t^1, c_t^2, \dots, c_t^L)$ are the hierarchical discrete semantic tokens representing item $I_t$.

---

Part 9: Evaluation Metrics, Losses & Offline-Online Mismatch

Robust evaluation requires both offline statistical testing and online live-traffic experimentation.

Metric Definitions

Retrieval Metrics (Top-K Candidates)

\[\text{Recall}@K = \frac{\vert{}\text{Relevant Items} \cap \text{Top-}K \text{ Recommended}\vert{}}{\vert{}\text{Total Relevant Items}\vert{}}\] \[\text{Hit Rate}@K = \mathbb{I}\left( \vert{}\text{Relevant Items} \cap \text{Top-}K\vert{} > 0 \right)\]

Ranking Metrics

Mean Reciprocal Rank (MRR):

\[\text{MRR} = \frac{1}{\vert{}U\vert{}} \sum_{u=1}^{\vert{}U\vert{}} \frac{1}{\text{rank}_u^*}\]

Mean Average Precision (MAP@K):

\[\text{MAP}@K = \frac{1}{\vert{}U\vert{}} \sum_{u=1}^{\vert{}U\vert{}} \left( \frac{1}{\min(m_u, K)} \sum_{k=1}^K P@k \cdot \text{rel}(k) \right)\]

Normalized Discounted Cumulative Gain (NDCG@K):

\[\text{DCG}@K = \sum_{i=1}^K \frac{2^{\text{rel}_i} - 1}{\log_2(i + 1)}, \quad \text{NDCG}@K = \frac{\text{DCG}@K}{\text{IDCG}@K}\]

Common Production System Failures

+---------------------------+-----------------------------------+--------------------------------------+
| Challenge                 | Cause                             | System Mitigation Strategy           |
+---------------------------+-----------------------------------+--------------------------------------+
| Result Reproducibility    | Non-deterministic distributed ops | Standardize seed state & logging     |
| Offline-Online Mismatch   | Data leakage / Shifted distributions| Strict feature store logging time-cut|
| Oscillating Outputs       | Feedback loops in real-time updates| Dynamic output dampening / MAB policies|
| Slow Convergence          | Sparse gradient updates on IDs    | Adagrad/FTRL for sparse embeddings   |
+---------------------------+-----------------------------------+--------------------------------------+

---

Part 10: Biases, Cold-Start & Content Moderation

Addressing system biases and edge cases is essential for model performance and user safety.

Systemic Biases and Mitigation Strategies

                          Biases in RecSys
                                |
    +---------------------------+---------------------------+
    |                           |                           |
Position Bias              Popularity Bias            Selection Bias
(Higher rank = higher CTR) (Popular items dominate)  (Missing unobserved data)
    |                           |                           |
    v                           v                           v
Propensity Scoring          Logit Correction          Counterfactual Weights
  1 / P(Exposed)             s_adj = s - tau*log(p)    Inverse Propensity Score

Position Bias Correction via Propensity Scoring

User engagement $Y$ depends on relevance $R$ and display position observation $O$:

\[P(Y=1 \mid \text{position} = k) = P(R=1) \cdot P(O=1 \mid \text{position} = k)\]

Inverse Propensity Scoring (IPS) adjusts the evaluation loss:

\[\mathcal{L}_{\text{IPS}} = \sum_{i \in D} \frac{Y_i}{P(O_i = 1 \mid \text{position}_i)} \cdot \mathcal{L}_{\text{model}}(s_i, y_i)\]

Popularity Bias Mitigation via Logit Adjustment

Adjusts inference logits by subtracting scaled item frequencies $P(v)$:

\[s_{\text{adjusted}}(u, v) = s(u, v) - \tau \cdot \log P(v)\]

Where $\tau$ is a temperature hyperparameter controlling the degree of popularity penalization.

Cold-Start Mitigation Techniques

1. User Cold-Start: Use demographic priors, onboarding interest selectors, contextual bandits, and active learning queries.
2. Item Cold-Start: Cross-modal feature extraction (e.g., CLIP text-image embeddings), semantic IDs, and hybrid content-collaborative architectures.
3. System Cold-Start: Leverage domain transfer learning, heuristic rules, and metadata search indexing.

Content Moderation Pipelines

Raw Content Stream (Video / Image / Text)
              |
              v
  [ Early Moderation Layer ] ---> Immediate Reject (Static Blocklists, Hashes)
              |
              v
  [ In-Depth Moderation ]   ---> Async Multi-Modal Deep Neural Models
              |
              v
  [ Late Moderation Layer ]  ---> Contextual Safety Filters & Policy Rules
              |
              v
 Safe Recommendations Delivered

---

Part 11: Production Systems & Industrial Case Studies

Production architectures balance scale, latency, and business constraints across large item catalogs.

Overview of Industrial Implementations

+------------------+----------------------------------+-------------------------------------+
| Company          | Key Architecture Innovation      | Core Technical Highlights           |
+------------------+----------------------------------+-------------------------------------+
| YouTube          | Two-Stage DNN (Candidate + Rank) | Deep Candidate Gen + Weighted Logistic Reg |
| Netflix          | Page Generation & Evidence Selection| Template-based row construction + Thumbnails |
| Instagram Explore| 3-Pass Multi-Stage Funnel Filter  | Distilled model -> Fast NN -> Deep NN |
| Pinterest Pixie  | Graph Random Walks on Pin-Board  | In-memory graph traversal via Pixie |
| DoorDash         | Store-Level Sparsity Handling    | Search-Rec hybrid + Spatial constraints|
| Monolith (ByteDance)| Streaming Real-time Training | Collisionless Dynamic Embedding Tables|
+------------------+----------------------------------+-------------------------------------+

Instagram Explore 3-Pass Multi-Stage Ranking

Instagram reduces candidate sets through three distinct model passes:

Account Candidates (~few thousands)
       |
       v
Media Candidate Sampling (~500 Items)
       |
       v
+-------------------------------------------------------------+
| Pass 1: Distilled Model (Minimal features)                  |
| -> Output: Top 150 Candidates                               |
+-------------------------------------------------------------+
       |
       v
+-------------------------------------------------------------+
| Pass 2: Lightweight NN (Full dense features)               |
| -> Output: Top 50 Candidates                                |
+-------------------------------------------------------------+
       |
       v
+-------------------------------------------------------------+
| Pass 3: Deep Neural Network (Full dense + sparse features)  |
| -> Output: Top 25 Final Grid Candidates                     |
+-------------------------------------------------------------+

---

Part 12: Hands-On Implementation: PySpark ALS Music Recommender

This section details an end-to-end implicit-feedback recommendation pipeline implemented using PySpark and Alternating Least Squares (ALS) matrix factorization.

from pyspark.sql import SparkSession
from pyspark.sql.functions import col, count, desc
from pyspark.ml.feature import StringIndexer
from pyspark.ml.recommendation import ALS
from pyspark.ml.tuning import ParamGridBuilder, TrainValidationSplit
from pyspark.ml.evaluation import RegressionEvaluator

# 1. Initialize SparkSession
spark = SparkSession.builder \
    .appName("PySpark-Music-RecSys-ALS") \
    .config("spark.driver.memory", "8g") \
    .getOrCreate()

# 2. Load Dataset
file_path = "listenings.csv"
df_listenings = spark.read.format("csv") \
    .option("header", True) \
    .option("inferSchema", True) \
    .load(file_path)

# 3. Clean and Preprocess Data
df_cleaned = df_listenings.drop("date").na.drop()

# 4. Map String Identifiers to Numerical Indices
user_indexer = StringIndexer(inputCol="user_id", outputCol="user_idx")
track_indexer = StringIndexer(inputCol="track", outputCol="track_idx")

df_indexed = user_indexer.fit(df_cleaned).transform(df_cleaned)
df_indexed = track_indexer.fit(df_indexed).transform(df_indexed)

# 5. Aggregate Implicit Interaction Counts (Plays)
df_interactions = df_indexed.groupby("user_idx", "track_idx") \
    .agg(count("*").alias("play_count"))

# 6. Split Data into Train/Test Sets
train_data, test_data = df_interactions.randomSplit([0.8, 0.2], seed=42)

# 7. Configure Implicit Matrix Factorization (ALS Model)
als = ALS(
    userCol="user_idx",
    itemCol="track_idx",
    ratingCol="play_count",
    implicitPrefs=True,
    alpha=40.0,
    coldStartStrategy="drop",
    nonnegative=True
)

# 8. Hyperparameter Tuning Grid
param_grid = ParamGridBuilder() \
    .addGrid(als.rank, [10, 50]) \
    .addGrid(als.regParam, [0.01, 0.1]) \
    .build()

evaluator = RegressionEvaluator(
    metricName="rmse",
    labelCol="play_count",
    predictionCol="prediction"
)

tvs = TrainValidationSplit(
    estimator=als,
    estimatorParamMaps=param_grid,
    evaluator=evaluator,
    trainRatio=0.8
)

# 9. Model Fitting
model = tvs.fit(train_data)
best_als_model = model.bestModel

# 10. Generate Top-10 Recommendations for All Users
user_recommendations = best_als_model.recommendForAllUsers(10)
user_recommendations.show(5, truncate=False)

---

Technical Takeaways

1. System Architecture: Production recommenders use multi-stage funnels (Retrieval $\rightarrow$ Ranking $\rightarrow$ Re-ranking $\rightarrow$ Calibration) to manage the trade-off between catalog size and computational latency.
2. Feature Interactions: Models like DCN-v2 and DLRM rely on explicit matrix-vector feature interactions rather than deep MLPs alone to capture cross-feature patterns efficiently.
3. Loss Formulations: Contrastive in-batch cross-entropy loss with logQ correction handles item frequency bias in candidate generation networks.
4. Bandits & Exploration: Contextual Bandits and Thompson Sampling manage exploration-exploitation trade-offs to cold-start new items and adapt to short-term user feedback.
5. Post-Processing Calibration: Raw neural network scores must be recalibrated using methods like Platt Scaling or Isotonic Regression before downstream multi-objective ranking or display logic.