2nd/10_Wiki/Topics/AI_and_ML/Recommendation-Systems.md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-recommendation-systems	Recommendation Systems	10_Wiki/Topics	verified	self	RecSys Recommender Systems Recommendation Engine	none	A	0.9	applied	recsys machine-learning ranking retrieval		2026-05-10	pending	language framework python pytorch

Recommendation Systems

매 한 줄

"매 user × item 의 relevance prediction at scale". 매 collaborative filtering (Netflix Prize 2009) → matrix factorization → deep two-tower / sequential / generative recsys. 2026 현재 매 industrial stack 의 multi-stage (retrieval → ranking → re-ranking), 매 LLM-augmented (semantic ID, generative recsys, LLM reranker).

매 핵심

매 paradigms

• Content-based: item features × user profile (cold-start friendly).
• Collaborative filtering (CF): user-item interactions only.
  • Memory-based: user-user / item-item KNN.
  • Model-based: matrix factorization (MF, ALS, SVD++).
• Hybrid: CF + content (LightFM, DCN).
• Deep:
  • Two-tower: user-tower / item-tower → dot product (retrieval).
  • Sequential: SASRec, BERT4Rec, GRU4Rec — 매 user history sequence modeling.
  • DIN/DIEN: attention over user behaviors (Alibaba).
  • Graph: PinSage, LightGCN.
• Generative recsys (2024-2026): TIGER, semantic ID, LLM-as-recommender.

매 pipeline (industrial)

1. Candidate generation (retrieval): 100M items → 1000 (two-tower ANN, FAISS / ScaNN).
2. Ranking: 1000 → 100 (heavy DCN / DIN, full features).
3. Re-ranking: 100 → 10 (diversity, business rules, MMR, RL).
4. Serving: <100ms p99.

매 metrics

• Offline: Recall@K, NDCG@K, MAP, AUC, MRR.
• Online (A/B): CTR, conversion, dwell time, session length, retention.
• Diversity / fairness: ILD (intra-list diversity), exposure parity.

매 응용

1. E-commerce (Amazon, Coupang, Taobao).
2. Video / music (YouTube, TikTok, Spotify).
3. Social feed (Facebook, Twitter/X, LinkedIn).
4. News (Toutiao, Yahoo News).
5. Ads (Google Ads ranking).

💻 패턴

Matrix factorization (implicit ALS)

import implicit
from scipy.sparse import csr_matrix

# user-item interactions (rows=users, cols=items)
ui = csr_matrix(interactions)  # 1.0 for click, weighted by dwell

model = implicit.als.AlternatingLeastSquares(
    factors=128, regularization=0.01, iterations=20, use_gpu=True,
)
model.fit(ui)
recs = model.recommend(userid=42, user_items=ui[42], N=10)

Two-tower retrieval (PyTorch)

import torch
import torch.nn as nn

class TwoTower(nn.Module):
    def __init__(self, n_users, n_items, dim=128):
        super().__init__()
        self.u_emb = nn.Embedding(n_users, dim)
        self.i_emb = nn.Embedding(n_items, dim)
        self.u_mlp = nn.Sequential(nn.Linear(dim, dim), nn.ReLU(), nn.Linear(dim, dim))
        self.i_mlp = nn.Sequential(nn.Linear(dim, dim), nn.ReLU(), nn.Linear(dim, dim))

    def user_repr(self, u): return nn.functional.normalize(self.u_mlp(self.u_emb(u)), dim=-1)
    def item_repr(self, i): return nn.functional.normalize(self.i_mlp(self.i_emb(i)), dim=-1)

    def forward(self, u, i_pos, i_negs):
        u_v = self.user_repr(u).unsqueeze(1)        # (B, 1, D)
        pos = self.item_repr(i_pos).unsqueeze(1)    # (B, 1, D)
        negs = self.item_repr(i_negs)               # (B, K, D)
        logits = torch.cat([u_v @ pos.transpose(-1,-2), u_v @ negs.transpose(-1,-2)], dim=-1).squeeze(1)
        labels = torch.zeros(u.size(0), dtype=torch.long, device=u.device)
        return nn.functional.cross_entropy(logits / 0.07, labels)  # in-batch + sampled negs

ANN retrieval with FAISS

import faiss, numpy as np

item_vecs = model.item_repr(torch.arange(n_items)).detach().cpu().numpy()
index = faiss.IndexFlatIP(128)        # inner product
index.add(item_vecs)

def retrieve(user_vec, k=1000):
    D, I = index.search(user_vec[None, :], k)
    return I[0]

SASRec (sequential recsys)

class SASRec(nn.Module):
    def __init__(self, n_items, dim=64, max_len=200, n_heads=2, n_layers=2):
        super().__init__()
        self.item_emb = nn.Embedding(n_items + 1, dim, padding_idx=0)
        self.pos_emb = nn.Embedding(max_len, dim)
        layer = nn.TransformerEncoderLayer(dim, n_heads, batch_first=True, activation="gelu")
        self.tr = nn.TransformerEncoder(layer, n_layers)

    def forward(self, seq):  # (B, L)
        L = seq.size(1)
        pos = torch.arange(L, device=seq.device).unsqueeze(0)
        x = self.item_emb(seq) + self.pos_emb(pos)
        mask = torch.triu(torch.ones(L, L), diagonal=1).bool().to(seq.device)
        h = self.tr(x, mask=mask)
        # next-item prediction
        return h @ self.item_emb.weight.T   # (B, L, V)

DIN-style attention over user history

class DINAttention(nn.Module):
    def __init__(self, dim):
        super().__init__()
        self.mlp = nn.Sequential(nn.Linear(4*dim, dim), nn.ReLU(), nn.Linear(dim, 1))

    def forward(self, target, history, mask):
        # target (B, D), history (B, L, D), mask (B, L)
        T = target.unsqueeze(1).expand_as(history)
        feats = torch.cat([T, history, T - history, T * history], dim=-1)
        attn = self.mlp(feats).squeeze(-1)
        attn = attn.masked_fill(~mask, -1e9).softmax(-1)
        return (attn.unsqueeze(-1) * history).sum(1)

LLM reranker (2026)

from anthropic import Anthropic
client = Anthropic()

def llm_rerank(user_history, candidates):
    msg = client.messages.create(
        model="claude-opus-4-7",
        max_tokens=500,
        messages=[{"role": "user", "content": f"""
User watched: {user_history}
Rerank these candidates by relevance, return top-10 IDs only as JSON array:
{candidates}
"""}],
    )
    return parse_json(msg.content[0].text)

Implicit feedback BPR loss

def bpr_loss(u, i_pos, i_neg, model):
    s_pos = (model.u(u) * model.i(i_pos)).sum(-1)
    s_neg = (model.u(u) * model.i(i_neg)).sum(-1)
    return -torch.log(torch.sigmoid(s_pos - s_neg) + 1e-12).mean()

매 결정 기준

상황	Approach
Cold-start (new user / item)	content-based + popularity
Small data (<10k users)	item-item KNN
Mid (10k-1M)	ALS / LightFM
Large (>1M, sequence behavior)	two-tower retrieval + DIN/SASRec ranking
Strict latency budget	two-tower + ANN
Need explanation / control	LLM reranker on top-100
Cross-domain (text + image)	multimodal embeddings (CLIP-style)

기본값: 매 industrial 의 two-tower retrieval + DCN/DIN ranking + business-rule rerank, 매 ANN (FAISS / ScaNN), 매 implicit feedback + sampled softmax. 매 LLM-as-reranker 의 emerging 2026 pattern for top-K refinement.

🔗 Graph

• 부모: Machine-Learning · Information-Retrieval
• 변형: Collaborative-Filtering · Two-Tower-Models · Sequential-Recsys
• 응용: E-commerce · Content-Recommendation · Ad-Ranking
• Adjacent: Embeddings · ANN-Search · Ranking-Loss · FAISS

🤖 LLM 활용

언제: cold-start (zero-shot recommendation from item description), reranker on top-100, explanation generation, semantic ID encoding. 언제 X: full-funnel retrieval at scale (latency / cost prohibitive). 매 LLM 의 reranker only, 매 retrieval 의 ANN.

❌ 안티패턴

• Random negative sampling only: easy negatives, model 의 saturate — use hard negatives + in-batch negatives.
• Train on biased logged data: position bias / popularity bias not corrected → IPS / counterfactual.
• Offline metric chasing: NDCG up but online CTR flat — online A/B 의 truth.
• Cold-start ignore: pure CF 의 fail on new items — hybrid fallback.
• No exploration: greedy ranking → filter bubble. ε-greedy / Thompson / contextual bandit.
• Single objective: CTR-only optimization 의 clickbait. Multi-objective (dwell, retention).

🧪 검증 / 중복

• Verified (Koren 2009 Netflix Prize, He LightGCN 2020, Kang SASRec 2018, Zhou DIN 2018, Covington YouTube DNN 2016, Google TIGER 2024).
• 신뢰도 A.

🕓 Changelog

날짜	변경
2026-05-08	Phase 1
2026-05-10	Manual cleanup — full canonical recsys with two-tower/SASRec/DIN/LLM-reranker