Recommender systems

Every lesson in this module found structure nobody labeled. This one closes the module on the version of that idea with the largest commercial footprint in machine-learning history: given a matrix of users × items where almost every entry is missing — most people have rated, watched, or bought almost nothing — predict the missing entries well enough to decide what to show next. The tool is one you already own: the dimensionality-reduction lesson’s low-rank factorization, pointed at a matrix that is 99% holes. The twist that makes it an engineering discipline rather than a linear-algebra exercise is what happens after deployment, when the model starts generating the very data it trains on.

The model: tastes are low-rank

The collaborative-filtering bet: the ratings matrix $R \in \mathbb{R}^{m \times n}$ is approximately rank $k$ with $k \ll m, n$ — user $u$‘s tastes compress to a vector $\mathbf{u}_u \in \mathbb{R}^k$, item $i$‘s character to $\mathbf{v}_i \in \mathbb{R}^k$, and a rating is their alignment:

The latent axes are learned, not named — but they come out interpretable often enough (serious↔escapist, mainstream↔niche) to justify the story: each user is a point in taste-space, each item a point in the same space, and recommendation is geometry. This is exactly the SVD lesson’s claim that meaning concentrates in a few directions — with one fatal complication. You cannot just run SVD: the matrix isn’t sparse-with-zeros, it is sparse-with-unknowns, and treating a missing rating as 0 teaches the model that everyone mildly dislikes everything they haven’t met. So the objective sums over observed entries only,

which loses the SVD’s closed form (the sum over $\Omega$ breaks orthogonality) and its convexity — like every factorization in this curriculum, the problem is biconvex: convex in $U$ with $V$ fixed and vice versa. That structure is the algorithm. Alternating least squares fixes $V$ and solves for each user’s $\mathbf{u}_u$ — which is nothing but a ridge regression of that user’s observed ratings onto the factors of the items they rated (the regularization lesson, verbatim) — then swaps roles. Each half-step solves its subproblem exactly, so the loss monotonically decreases; and because each user’s solve is independent, ALS parallelizes embarrassingly, which is why it scaled to industry first. (SGD on the same objective — Koren’s Netflix-era recipe — trades the clean solves for cheaper updates plus bias terms $\mu + b_u + b_i$ that soak up “this user grades harshly” and “this item is broadly loved” before the factors spend rank on them.)

Implicit feedback: learning from what nobody said

Ratings are rare; behaviour is torrential — clicks, watches, purchases, dwell. But implicit data has no negatives: a click means interest, an un-click means interest-or-never-seen, and now the missing entries carry information you can’t ignore the way the explicit objective did. The standard move (Hu, Koren & Volinsky, 2008) reframes: predict a binary preference $p_{ui} = \mathbb{1}[r_{ui} > 0]$ over all cells, but weight each term by a confidence $c_{ui} = 1 + \alpha\, r_{ui}$ that grows with observed engagement — unclicked cells participate as low-confidence zeros rather than trusted ones, and a clever bit of algebra keeps ALS tractable despite the sum now running over all $m \times n$ cells. The deeper reframe is that recommendation is a ranking problem, not a rating-regression problem: BPR-style losses optimize $\Pr(\text{clicked item scores above unclicked item})$ — pairwise logistic regression on score differences, the same Bradley–Terry structure the RL track’s preference-tuning lesson derives — which targets what the product actually does with the scores: sort.

The tail-eating: deployed recommenders make their own data

Everything above treats the data as given. In production the model chooses the data: users can only click what was shown, and what was shown is what the previous model scored highly. Three pathologies follow, and the causal inference lesson names them all. Position and exposure bias: an un-clicked item at rank 40 is not disliked, it is unseen — logged clicks confound relevance with exposure, so naive retraining learns the old model’s rankings back. The feedback loop: popular items get shown, get clicked, get more popular in the next training set — a rich-get-richer dynamic that narrows catalogs and, on content platforms, narrows users. Selection as a collider: the log conditions on “was recommended”, a variable caused by every signal the old model used, manufacturing spurious correlations exactly as Berkson’s paradox promises. The honest mitigations are causal moves, not better factorizations: inject randomized exploration (show some items by lottery, and weight those log entries as the near-experimental gold they are), model exposure explicitly with inverse-propensity weights $1/\Pr(\text{shown})$, and hold out truly random slates for evaluation. A recommender team without an exploration budget is training on the confounded exhaust of its own past decisions.

Evaluation, and the metric that lied for a decade

Offline, the field graded itself on rating RMSE for years — the Netflix Prize paid a million dollars for a 10% improvement in it (0.9514 → 0.8567) — before conceding that RMSE on held-out ratings barely correlates with what users do when shown a slate. What the product needs is top-of-list quality: precision@k (how much of the slate lands), NDCG (rank the hits high, discounted by position), coverage and diversity (is the model just replaying popularity?). And the offline/online gap never fully closes, because the log’s biases infect the test split too — which is why the last word belongs to the previous module’s territory: the A/B test, with engagement, retention, and guardrail metrics, on real slates. Offline metrics select candidates; experiments decide.

The modern architecture, in one paragraph, so the throughline is visible: industrial systems (YouTube’s two-stage design is the canonical write-up) split into a retrieval stage — a two-tower model where user and item towers each output an embedding and candidates are the item vectors nearest the user vector, which is precisely $\mathbf{u}^\top \mathbf{v}$ with the factorization replaced by learned networks over features, killing cold-start by construction — and a ranking stage, a gradient-boosted or neural model over rich features that orders the few hundred survivors. Matrix factorization didn’t die; it became the retrieval geometry, and its embedding-dot-product core is the same operation the LLM track’s embedding lesson builds search on.

Exercises