Every feed, search box and ad slot runs the same funnel — build yours end to end and prove with real numbers that it beats popularity.
You have a catalog of millions of items, a user who will look at maybe ten of them, and about 200 milliseconds to choose which ten. That is the problem behind every Netflix row, Spotify mix, Amazon "you might also like" strip and search results page, and no single model solves it. This course builds the real thing in stages, in Python, on real interaction data. Module 1 gets you a working recommender that beats a popularity baseline. Then you add collaborative filtering (matrix factorization, alternating least squares, Bayesian personalized ranking) and content-based retrieval with two-tower embedding models. You train rankers next: gradient-boosted LambdaMART, then deep ones (Wide & Deep, Deep & Cross Network, Meta's Deep Learning Recommendation Model). You make retrieval fast with approximate nearest-neighbor indexes: hierarchical navigable small world (HNSW) graphs, product quantization and Meta's FAISS library, plus two Go services on the latency-critical path. The back half separates a demo from a product: honest evaluation (normalized discounted cumulative gain, calibration, A/B tests, off-policy estimates), ad auctions and budget pacing, feature stores and latency budgets, then cold start, bandit exploration, diversity and fairness. You finish with a two-stage recommender you can actually serve.
Built by Lakshya Kumar
We grant free access case-by-case — students, career-switchers, builders on a tight budget. Sign in to send us a note.
Sign in to applyFinished the tasks? Take the prompt to your AI and get tested on it. We copy the prompt and open the app — just paste it in.
You never need to know what an item is: patterns in who liked what are enough to predict what someone will want next.
Turn items and users into vectors so a two-tower model can retrieve good matches even for things nobody has clicked yet.
Sorting by predicted score is not the same as ordering a list well — train on pairs and whole lists, and ranking quality jumps.
Neural rankers find interactions you'd never hand-engineer — and quietly break your calibration if you don't watch for it.
Brute force dies at a million items; approximate nearest-neighbor indexes trade a sliver of accuracy for a thousandfold speedup.
Most offline wins vanish in production — pick metrics that correlate, run A/B tests that hold up, and learn from logged data.
A miscalibrated click prediction is a billing error — build the auction, the pacing and the quality score that keep it honest.
The model that wins offline still has to answer in 50ms with features computed seconds ago — a different engineering problem.
Bandits get new items seen, diversity re-ranking breaks the filter bubble, and fairness metrics show who your feed quietly ignores.
Complete all modules, then submit the required number of capstone projects. Each must earn a passing rating from an admin reviewer.
Build a real two-stage recommender (retrieval + ranking) on a real dataset (MovieLens, Amazon reviews, or an equivalent public interaction dataset). It must beat a popularity baseline on offline metrics (recall@10 and NDCG@10) using a genuine time-based train/test split, and include a serving demo (a script or lightweight API) that returns real ranked recommendations for a real user in under a specified latency budget. Submit the code, your offline metric report against the baseline, and a short writeup of your architecture choices.
Paste this into any AI chat. Fill in the bracketed parts with your context — you'll get back a straight answer on whether this belongs on your plate.
I'm taking a "Recommender Systems, Ranking & Search" course. It covers, in order: the retrieval-ranking-re-ranking funnel and objectives vs proxy metrics; collaborative filtering (matrix factorization, ALS, BPR); content-based signals and embeddings (two-tower retrieval, negative sampling, ANN fundamentals); learning to rank (pointwise, pairwise, listwise, LambdaMART); deep ranking (Wide & Deep, DCN, DLRM, sequence/transformer rankers); candidate generation at scale (HNSW, IVF, product quantization, FAISS, vector databases, hybrid retrieval); evaluation (precision/recall/MAP/NDCG, AUC vs calibration, A/B testing, counterfactual/interleaving); ads and auctions (pCTR/pCVR, second-price/GSP, budget pacing, quality score); serving and features (feature stores, freshness, latency budgets, shadow deployment); and cold start, bandits, diversity, and fairness. My context: 1. What I'm building or want to build: [describe — a content feed, e-commerce recommendations, a search box, an ad system, or "just learning"] 2. My current data situation: [no interaction data yet / some implicit logs / rich explicit+implicit data] 3. My biggest current pain point: [cold start / poor relevance / slow serving latency / no way to evaluate changes / I don't have a recommender yet] 4. My background: [comfortable with basic ML / new to ML entirely / strong software engineer, new to ML specifically] Given that, answer: - Which module should I start with, and why, given my current pain point? - Name the single simplest baseline (from Module 1 or 2) I should build this week before anything fancier. - Given my data situation, is collaborative filtering, content-based, or a hybrid the right starting architecture — and why? - What's the first evaluation metric I should track, and what value would tell me I'm ready to move on to a more complex technique? - Name one thing this course will NOT solve for me (e.g. a specific infra product, a specific vendor's API), so I have the right expectations.
On a single query-grouped ranking dataset with engineered features, train and fairly compare at least three ranking approaches from this course (a pointwise baseline, LambdaMART, and one deep ranker — DCN, DLRM, or a sequence model). Report NDCG@5/@10 and MAP for each on an identical query-based held-out split, plus a calibration check for at least one model. Submit the code, the comparison table, and a writeup of which model you'd actually ship and why, given your dataset's size.
Build a bandit-driven exploration system (epsilon-greedy, Thompson Sampling, or a contextual bandit like LinUCB) that measurably accelerates learning for cold-start items on a real or realistic catalog, layered with MMR diversity re-ranking and an exposure-fairness measurement (Gini coefficient or top-k share). Demonstrate, with real numbers, how quickly your system identifies a genuinely good new item compared to a no-exploration baseline, and report the relevance/diversity/fairness trade-offs you made.
The reference for the retrieval funnel (Module 1) and two-tower retrieval (Module 3).