AI: Chatbots & Recommendation Engines

Course logistics, organization & intro orientation

Objective: understand how the course runs, the assessment structure and the group-project expectations.

• Syllabus & assessment map: the 35/30/25/10 split, the three project checkpoints, attendance and re-sit rules.
• GenAI policy: encouraged but critically — verify, refine, and acknowledge use.
• Team formation & tooling: forming project groups and previewing the Python/GitHub stack used later.

• Read · Aggarwal, Recommender Systems: The Textbook, ch. 1 (an introduction to recommender systems) to set context.

Introduction to recommendation & chatbots

Objective: define the recommendation problem formally and survey where recommenders and chatbots create business value.

• The utility function: a recommender learns a score $g(u,i)$ for every (user, item) pair and, for each user, returns the highest-scoring items. Everything in the course — neighborhoods, latent factors, neural nets — is a different way to estimate this one function. Intuitively, $g$ encodes "how much would user $u$ like item $i$?" and the whole pipeline exists to fill in the unobserved entries of a giant, mostly-empty table.
• Rating vs ranking: predicting a numeric utility (regression, e.g. "4.2 stars") is a different task from producing the right ordered list (ranking). A model can have great RMSE yet rank badly, because users only ever see the top of the list — which is why ranking metrics (Session 5) often matter more than rating error.
• Business framing: recommenders reduce search cost, improve UX and surface the long tail (the many niche items no human could browse); chatbots add an interactive search/serving channel. Concretely, ~⅓ of Amazon purchases and the majority of Netflix viewing originate from recommendations.

• Read · Aggarwal ch. 1 — the goals of recommender systems and the rating-vs-ranking distinction. Skim · Li et al., Frontiers and Practices intro for the industry view (why reco is a revenue lever, not a feature).

Data in recommendation systems

Objective: understand the raw material of a recommender — feedback signals, their structure and their pathologies.

• Explicit feedback: deliberate signals such as ★ ratings, thumbs and likes. The meaning is unambiguous (a 5 really means "loved it"), but users rate only a tiny fraction of what they consume, so explicit data is precious and scarce — and biased toward people who bother to rate.
• Implicit feedback: behavioural traces — clicks, views, dwell time, add-to-cart, purchases, skips. Abundant and cheap, but ambiguous: a click can be a misclick, and a non-click can mean "unseen" rather than "disliked". A common modelling trick is to treat interactions as positive with a confidence that grows with the count (e.g. $c_{ui}=1+\alpha r_{ui}$ in implicit-ALS).
• Sparsity & the long tail: the user-item matrix is typically >99% empty, and interactions follow a power law — a few blockbuster items get most of the feedback while the long tail gets almost none. Worked intuition: 10⁶ users × 10⁵ items = 10¹¹ cells, but if each user touches ~100 items only ~10⁸ are filled — density ≈ 0.1%.
• Missing-not-at-random (MNAR): the entries you observe are not a random sample — users choose what to rate, and the system chose what to show. So absence of a rating is not a negative label, and naive "treat blanks as 0" training systematically distorts the model.

• Read · Aggarwal ch. 2 (rating types, neighborhood data); Concept · implicit-feedback & confidence weighting in Li et al. (Hu, Koren & Volinsky's implicit-ALS is the canonical reference).

Recommendation-systems algorithms overview

Objective: map the landscape of recommender families and their trade-offs before going deep on any one.

• Non-personalized: the same list for everyone — random, or ranked by popularity / average rating. Trivial to build and a surprisingly strong baseline; the right fix for sparse averages is a Bayesian average that shrinks low-count items toward the global mean: $\bar r_i=\frac{C\mu+\sum_j r_{ij}}{C+n_i}$, so a 5.0 from two ratings doesn't outrank a 4.6 from a thousand.
• Content-based: build a profile from the features of items a user liked, then score new items by feature match. Handles brand-new items (no interactions needed) and is explainable ("because you watched sci-fi"), but over-specializes into a filter bubble and can't surprise the user.
• Collaborative filtering: learn purely from feedback patterns across users — "people like you liked this" — with no item metadata. Powerful and serendipitous, but cold-start-prone (needs history) and hurt by sparsity.
• Hybrid: combine the above to cancel each other's weaknesses — weighted (blend scores), switching (use CB when CF lacks data), or mixed (present both). Most production systems are hybrids.
• Context-aware (CARS): extend the pair to $g:U\times I\times C\to\mathbb{R}$ with context such as time, location or device, via pre-filtering, post-filtering or full contextual modelling (e.g. "lunch spots at noon, near me").

• Read · Aggarwal ch. 1 §1.3 (taxonomy) — keep this map handy all term; ch. 4 (content-based) & ch. 2 (neighborhood CF) as previews.

Evaluation, model selection & operationalization

Objective: learn how to judge a recommender offline, choose between models, and reason about serving it in production.

• Regression metrics: MAE, MSE, RMSE and R² for rating prediction. RMSE squares errors, so it punishes a few large mistakes harder than MAE; use it when big misses are costly.
• Classification metrics: precision, recall, F1, accuracy and the ROC/AUC curve for the relevant-vs-not view. In top-K reco, precision@K = (relevant in top K)/K answers "of what I showed, how much was good?", while recall@K answers "of all good items, how much did I surface?".
• Ranking metrics: CG, DCG, NDCG, MRR and Precision@K — here order is everything because users scan from the top down. NDCG discounts gains by log-position and normalizes against the ideal ordering, giving a score in $[0,1]$.
• Beyond accuracy: coverage (what fraction of the catalog ever gets shown), diversity (intra-list similarity), novelty and personalization — dimensions a pure accuracy number is blind to.
• Data splits: random, per-user stratified, and time-based (train on the past, test on the future — the only honest split for a deployed system); offline metrics vs the online A/B-test reality.

• Read · Aggarwal ch. 7 (evaluating recommender systems); Concept · NDCG & offline/online evaluation in Li et al.

Project discussion — presentation of projects project

Objective: present and refine group-project proposals — problem, dataset, baseline and success metric.

• Problem & dataset: who are the users, what are the items, what feedback is available (explicit/implicit)?
• Baseline & metric: choose a non-personalized baseline (popularity / Bayesian average) and the single metric you will improve — matched to the task (rating vs ranking) per Session 5.
• Peer feedback: tighten scope and de-risk early.

Project discussion — presentation of projects project

Objective: complete proposal presentations and lock the project plan and team responsibilities.

• Remaining presentations and consolidated feedback.
• Work plan: milestones aligned to the mid-term (S15–16) and final (S24–25) checkpoints.
• Individual contribution plan: who owns what (feeds the 25% contributions grade).

Development practices — set up project & GitHub lab

Objective: stand up a reproducible project skeleton under version control.

• Repository structure: data / src / notebooks / tests separation; README and config.
• Git & GitHub workflow: branches, commits, pull requests, code review.
• Environments: virtual environments and pinned dependencies for reproducibility.

Development practices — Python practices lab

Objective: write clean, testable Python for data and ML workloads.

• Idiomatic Python & the data stack: NumPy / pandas vectorization, avoiding hidden loops.
• Modularity & testing: functions over scripts, unit tests, type hints, linting.
• Performance basics: sparse matrices for large user-item data.

Invited guest — product management guest

Objective: see how recommendation/chatbot features are prioritized and shipped in industry.

• From metric to roadmap: turning model gains into product decisions.
• Experimentation culture: A/B tests, guardrail metrics, and knowing when offline wins don't ship.
• Stakeholders: aligning data science, engineering and business.

Similarity-based methods

Objective: build memory-based collaborative filtering from similarity between users or items.

• Cosine similarity: the cosine of the angle between two rating/feature vectors — it measures direction (taste pattern), ignoring magnitude, so a generous and a stingy rater with the same pattern still look similar. Ranges $[0,1]$ for non-negative vectors. Worked example: $A=[5,0,3],\,B=[4,0,2]$ ⇒ $A\!\cdot\!B=26$, $\lVert A\rVert=\sqrt{34}=5.83$, $\lVert B\rVert=\sqrt{20}=4.47$, so $\cos\theta=26/(5.83\cdot4.47)\approx\mathbf{0.998}$ — near-identical taste.
• Pearson correlation: cosine on mean-centred ratings — subtracts each user's average first, which corrects for rating-scale bias and is often preferred for explicit ratings.
• User-based CF: find users whose history is similar to yours, then recommend what they liked. Intuitive but the user-user matrix shifts constantly and is expensive to keep fresh.
• Item-based CF: find items similar to those you already liked. Item-item relationships are far more stable over time and can be precomputed offline, which is why Amazon's classic engine is item-based.
• KNN prediction: a similarity-weighted average of the neighbours' ratings — closer (more similar) neighbours count more.

• Read · Aggarwal ch. 2 (neighborhood-based CF — derivations of user/item similarity and prediction); Concept · similarity functions in Li et al. Classic: Sarwar et al., "Item-Based Collaborative Filtering".

Matrix factorization & factorization machines

Objective: learn latent-factor models that decompose the sparse rating matrix into low-rank factors.

• Latent factors: approximate the sparse rating matrix as $R\approx UV^{T}$, where each user and each item is a vector of $k$ hidden dimensions (e.g. "amount of comedy", "indie-ness") discovered by the model. A predicted rating is just the dot product $p_u^{T}q_i$ — aligned vectors score high.
• SVD with biases: pure dot products miss that some users rate high and some items are universally liked; adding a global mean $\mu$ and user/item biases $b_u,b_i$ fixes most of this before the factors do any work.
• The objective: minimize squared error on the observed entries only, with L2 regularization to stop the factors from overfitting the sparse data (see formula).
• Learning: regularized gradient descent over observed entries — SGD (one rating at a time) or ALS (fix one factor matrix, solve the other in closed form; embarrassingly parallel).
• Factorization machines: generalize MF to model all pairwise interactions among arbitrary features (user, item, context, side-info), unifying recommendation with regression and handling cold-start via features.

• Read · Aggarwal ch. 3 (model-based CF / latent factor models — full derivation); Koren, Bell & Volinsky, "Matrix Factorization Techniques for Recommender Systems" (the classic, readable survey behind the Netflix Prize).

Applying general machine learning to recommendation

Objective: frame recommendation as a standard supervised-learning problem and bring the full ML toolbox.

• Feature engineering: turn users, items and interactions into a feature vector — user demographics, item metadata, recency/frequency, and text via bag-of-words / TF-IDF or embeddings. The label is the interaction (click, purchase, rating).
• TF-IDF intuition: weight each word by how often it appears in a document (TF) times how rare it is across the corpus (IDF), so common words like "the" get crushed and distinctive words dominate the profile. Worked example: in a 1,000-document corpus, "thriller" appears in 10 of them and 3× in this movie's synopsis ⇒ TF·IDF $=3\cdot\log(1000/10)=3\cdot2=\mathbf{6}$; "the" in all 1,000 ⇒ $\log(1000/1000)=0$, contributing nothing.
• Models: logistic regression (fast, explainable), gradient-boosted trees (XGBoost/LightGBM — the industry workhorse for tabular click prediction), and neural nets.
• Hyperparameter tuning: grid/random search vs Bayesian optimization, which models the score surface and samples where improvement is likely — far fewer trials when each training run is expensive.
• Cold-start via content: because the model scores from features, it can rate a brand-new item or user with zero interaction history — the structural fix for the cold-start problem of Session 3.

• Read · Aggarwal ch. 4–5 (content-based & knowledge-based); Rendle, "Factorization Machines" (the unifying view of MF and regression).

MLOps for recommendation & chatbots

Objective: take a trained model from notebook to a monitored, retrainable production service.

• Pipelines: reproducible, version-controlled training and feature pipelines; data and model versioning so any result can be reproduced and rolled back.
• Serving architectures: batch (precompute lists nightly — cheap, but stale) vs real-time (score on request — fresh, costly) vs multi-stage vs hybrid; the choice is a latency/freshness/cost trade-off.
• Monitoring & retraining: watch for data and concept drift (the world changes, the model goes stale), collect feedback, and retrain on a schedule or a trigger.
• The production funnel: retrieval (millions → thousands, cheap) → filtering (business rules) → scoring (rich model) → ordering/re-ranking (diversity, freshness).

• Read · Li et al., MLOps / system-design chapters; Concept · multi-stage ranking architectures.

Mid-term project presentation project

Objective: present working progress — baseline beaten, first real model, honest metrics.

• Pipeline & baseline results; first personalized model vs the baseline.
• Evaluation: the chosen offline metric and what it does/doesn't capture.
• Risks & next steps toward the final.

Mid-term project presentation project

Objective: finish mid-term presentations and integrate feedback into the final plan.

• Remaining presentations and cross-team feedback.
• Plan adjustment for the back half of the course (DL, sequential, graph, chatbots).

Deep-learning models in recommendation systems

Objective: understand neural recommenders and how embeddings replace hand-crafted similarity.

• Embeddings: learned dense vectors that place similar users/items/words near each other in space; static (Word2Vec/GloVe — one vector per word) vs contextual (BERT — the vector depends on the sentence). The same idea as MF's latent factors, now learned end-to-end.
• Neural CF & two-tower models: replace the fixed dot product with a learned non-linear scorer (NCF). The two-tower design encodes user and item separately so item vectors can be precomputed and searched with fast approximate nearest-neighbour — the standard retrieval architecture at scale.
• Learning to rank: optimize the order directly — pointwise (predict each score independently), pairwise (BPR: rank a positive above a sampled negative), or listwise (optimize a whole-list metric). BPR in words: for an observed item $i$ and an unobserved $j$, push $\hat r_{ui}$ above $\hat r_{uj}$ by maximizing $\ln\sigma(\hat r_{ui}-\hat r_{uj})$; when $\hat r_{ui}\!-\!\hat r_{uj}=2$, $\sigma(2)\approx0.88$, so the pair is already well-ordered and contributes little gradient.
• Dimensionality reduction: PCA to compress and visualize high-dimensional embeddings in 2–3D.

• Read · Li et al., deep-learning-for-recommendation chapters; "Neural Collaborative Filtering" (He et al.).

Sequential recommendation systems

Objective: model the order of a user's interactions to predict the next one.

• Session-based & next-item prediction: given the recent sequence $(i_1,\dots,i_{t})$, predict $i_{t+1}$ — crucial when you only have an anonymous session, not a long user history.
• Architectures: RNN/GRU (GRU4Rec) process the sequence step by step; self-attention/transformer models (SASRec left-to-right, BERT4Rec with masking) let any past item attend to any other and train far faster — the same attention machinery as Session 22.
• Temporal dynamics: tastes drift, items go in and out of fashion, and intent within a session is short-lived — a key Netflix-Prize lesson (time-aware models beat static ones).

• Read · Li et al., sequential-recommendation chapter; SASRec (Kang & McAuley) for the self-attention approach; GRU4Rec (Hidasi et al.) for the RNN baseline.

Graph recommendation systems

Objective: exploit the user-item interaction graph with graph neural networks.

• Bipartite graph: users and items are two node sets, interactions are edges — a graph view of the very same user-item matrix from Session 3.
• Graph neural networks: each node repeatedly aggregates ("message-passes") its neighbours' embeddings; after $L$ layers a node has absorbed information from $L$ hops away. LightGCN strips the GNN down to just neighbour averaging and shows the heavy non-linearities often don't help for reco.
• High-order connectivity: stacking layers captures multi-hop "users who liked X also liked Y, and those users also liked Z" paths that a flat dot product can't see.

• Read · Li et al., graph-based recommendation chapter; LightGCN (He et al.) and NGCF for the message-passing formulation.

Introduction to chatbots

Objective: understand the classical chatbot stack and how conversational systems are structured.

• Chatbot types: rule-based (scripted patterns — predictable, brittle), retrieval-based (pick the best response from a fixed set — safe, can't generalize), and generative (compose a new response — flexible, can hallucinate).
• Intent & NLU: classify the user's intent (e.g. book_flight) and extract entities/slots (date, destination) from an utterance — a text-classification + sequence-labelling problem, mirroring Session 13's "text as features".
• Dialog management: track conversation state and decide the next action/response (the policy), then realize it as text (NLG).

• Read · Alto, Building LLM Powered Applications, early chapters on conversational AI and the classical NLU pipeline.

Q&A modern methodologies: autoencoders & autoregressive algorithms

Objective: contrast the two dominant transformer paradigms behind modern Q&A.

• Autoencoding (BERT-style): bidirectional, masked-language-model pre-training — great for understanding/extraction.
• Autoregressive (GPT-style): left-to-right next-token prediction — great for generation.
• Extractive vs generative Q&A: pointing to a span vs composing an answer.