系统设计：推荐系统

从召回到精排，构建千万级用户的个性化推荐架构。

推荐系统是互联网公司最核心的系统之一，直接影响用户留存和商业化收入。面试中常要求设计一个完整的推荐架构，考查候选人对算法、工程、数据三者的综合能力。

场景分析（Scenario）

需求

• 功能需求：为用户推荐个性化内容（新闻、视频、商品等）
• 用户规模：DAU 1000 万，日均请求 10 亿次
• 延迟要求：首页推荐 < 200ms，非首页 < 500ms
• 内容规模：物品池 1 亿+，日新增 100 万

核心挑战

1. 海量物品如何快速召回：从 1 亿候选中选出数百个
2. 实时兴趣捕捉：用户刚刚点了赞，下次刷新要体现
3. 冷启动：新用户、新物品无历史数据
4. 多样性与新颖性：避免信息茧房
5. Exploration vs Exploitation：已知兴趣 vs 新领域探索

服务架构（Service）

┌─────────────┐    ┌─────────────────────────────────────────────┐
│   Client    │───▶│         Recommendation Service                │
└─────────────┘    │  ┌────────┐  ┌────────┐  ┌──────┐  ┌──────┐ │
                   │  │ Recall │─▶│  Pre-Rank  │─▶│ Rank │─▶│ ReRank│ │
                   │  └────────┘  └────────┘  └──────┘  └──────┘ │
                   └─────────────────────────────────────────────┘
                            │              │              │
                   ┌────────▼──────┐  ┌─────▼──────┐  ┌──▼─────┐
                   │ Feature Store │  │ Model Service │  │ Rule Engine│
                   └───────────────┘  └──────────────┘  └─────────┘

四阶段漏斗

召回层（Recall）

召回层必须在 < 20ms 内从 1 亿候选中选出数百个。核心思想：多路召回 + 倒排索引。

多路召回策略

协同过滤（Collaborative Filtering）

用户协同过滤（User-CF）

找到与目标用户兴趣相似的用户，推荐他们喜欢的物品。

import numpy as np
from scipy.spatial.distance import cosine

def user_cf(ratings, target_user, k=5):
    """
    ratings: user-item matrix (users x items)
    target_user: index of the user
    """
    user_sim = 1 - np.array([
        cosine(ratings[target_user], ratings[u])
        if np.sum(ratings[u]) > 0 else 0
        for u in range(len(ratings))
    ])

    # Exclude self, get top-k similar users
    user_sim[target_user] = -1
    top_k_users = np.argsort(user_sim)[-k:]

    # Aggregate ratings from similar users
    scores = np.zeros(ratings.shape[1])
    for u in top_k_users:
        scores += user_sim[u] * ratings[u]

    # Recommend items target user hasn't seen
    seen = ratings[target_user] > 0
    scores[seen] = 0
    return np.argsort(scores)[::-1][:10]

问题：用户矩阵往往非常稀疏，计算复杂度高 (O(U^2))。

物品协同过滤（Item-CF）

更适合用户量级远大于物品量级的场景（如电商）。

计算物品之间的共现相似度：

$$sim(i, j) = \frac{|N(i) \cap N(j)|}{\sqrt{|N(i)| \cdot |N(j)|}}$$

优势：物品相似矩阵更稳定（物品变化慢），推荐更有可解释性。

向量召回：双塔模型（Two-Tower Model）

User Tower                    Item Tower
┌──────────┐                 ┌──────────┐
│ User ID  │                 │ Item ID  │
│ Profile  │                 │ Category │
│ History  │─▶ Embedding ──▶ │ Tags     │
│ Context  │                 │ Stats    │
└──────────┘                 └──────────┘
     │                            │
     └───────── Sim(Q, I) ────────┘

• 用户塔和物品塔分别输出固定维度的 embedding
• 通过内积/余弦相似度计算匹配分数
• 物品 embedding 预先计算并写入 ANN 索引库

近似最近邻（ANN）索引

向量召回需要快速搜索最相似的 K 个物品：

精排层（Ranking）

精排层提供精确的 CTR（点击率）或 CVR（转化率）预估。

###特征体系

###排序模型演进

DeepFM 简化结构

import torch
import torch.nn as nn

class DeepFM(nn.Module):
    """简化版 DeepFM 用于理解核心结构"""
    def __init__(self, field_dims, embed_dim=8, mlp_dims=[64, 32]):
        super().__init__()
        self.num_fields = len(field_dims)

        # Embedding layer (shared by FM and Deep)
        self.embedding = nn.ModuleList([
            nn.Embedding(dim, embed_dim) for dim in field_dims
        ])

        # FM 一阶线性部分
        self.fm_first = nn.ModuleList([
            nn.Embedding(dim, 1) for dim in field_dims
        ])

        # Deep MLP
        input_dim = self.num_fields * embed_dim
        layers = []
        for dim in mlp_dims:
            layers.extend([nn.Linear(input_dim, dim), nn.ReLU(), nn.Dropout(0.2)])
            input_dim = dim
        layers.append(nn.Linear(input_dim, 1))
        self.mlp = nn.Sequential(*layers)

    def fm_layer(self, embeddings):
        """
        FM 二阶交叉: sum(sum(vi * vj)) = 0.5 * [ (sum vi)^2 - sum(vi^2) ]
        embeddings: [batch, num_fields, embed_dim]
        """
        square_of_sum = torch.sum(embeddings, dim=1) ** 2
        sum_of_square = torch.sum(embeddings ** 2, dim=1)
        fm_out = 0.5 * torch.sum(square_of_sum - sum_of_square, dim=1, keepdim=True)
        return fm_out

    def forward(self, x):
        # x: [batch, num_fields] 每个 field 的离散 ID
        # Embedding lookup
        embeddings = torch.stack([
            self.embedding[i](x[:, i]) for i in range(self.num_fields)
        ], dim=1)  # [batch, num_fields, embed_dim]

        # FM first-order
        fm_first = torch.sum(
            torch.stack([self.fm_first[i](x[:, i]) for i in range(self.num_fields)], dim=1),
            dim=1
        )  # [batch, 1]

        # FM second-order
        fm_second = self.fm_layer(embeddings)

        # Deep part
        deep_input = embeddings.view(x.size(0), -1)
        deep_out = self.mlp(deep_input)

        # Final prediction (sigmoid in loss)
        return fm_first + fm_second + deep_out

多目标优化（MMoE）

推荐系统往往同时优化多个目标：

• 点击（CTR）：用户是否点击
• 点赞/收藏（ Engagement） ：浅层互动
• 停留时长（Dwell Time） ：深度消费
• 分享/评论（Conversion） ：深层转化

使用 MMoE（Multi-gate Mixture-of-Experts）共享底层表示，同时优化多个目标。

重排层（Re-Rank）

重排层关注用户体验，目标是：多样性 + 新颖性 + 业务规则。

多样性算法：MMR（Maximal Marginal Relevance）

$$MMR = \lambda \cdot Relevance(S_i) - (1 - \lambda) \cdot \max_{S_j \in R} Similarity(S_i, S_j)$$

• 平衡相关性与多样性
• 高相关性且与已选物品差异大的物品得分高

业务规则插入

• 必出规则：运营活动、新品扶持
• 打散规则：同类目不超过连续 3 个
• 频率控制：同一作者/品牌间隔不低于 N 个
• 负反馈过滤：用户点过"不喜欢"的物品过滤

存储设计（Storage）

数据流架构

User Behavior ──▶ Kafka ──▶ Flink ──▶ Feature Store
                                    │         │
                                    ▼         ▼
                              Training      Online Serving
                                    │         │
                                    └─▶ Model Store ◀── Train Pipeline

存储选型

冷启动策略

Bandit 算法：解决 Exploration

• Epsilon-Greedy：以 ε 概率随机探索
• UCB（Upper Confidence Bound） ：兼顾均值和方差
• Thompson Sampling：贝叶斯采样，平衡探索和利用

实时推荐

近实时特征更新

点击 ──▶ Kafka ──▶ Flink 窗口聚合 ──▶ Redis Feature Store
                                         │
用户刷新 ──────────────────────────────▶ 推荐服务读取最新特征

• Flink 滑动窗口实时计算用户最近行为特征
• 写入 Redis TTL 7 天
• 推荐服务读取时合并实时 + 离线特征

面试答题框架

推荐系统面试回答结构

阶段一：需求澄清（2 分钟）

• 推荐什么内容？新闻/视频/商品？
• 用户规模、物品规模、QPS 预期
• 实时性要求？能否接受 T+1 离线计算？

阶段二：召回层设计（5 分钟）

• 多路召回策略（CF + CB + Vector + Hot）
• 每路召回的数量和分数归一化
• ANN 索引选型（Faiss / Milvus）
• 如何评估召回质量（Recall@K）

阶段三：排序层设计（5 分钟）

• 特征工程：用户/物品/交叉/上下文/序列
• 模型选型：从 LR → DeepFM → DIN 的演进
• 在线 serving：TensorFlow Serving / Triton
• 多目标优化是否必要？

阶段四：重排与体验（3 分钟）

• 多样性：MMR、类目打散
• 新颖性：EE 问题、Bandit 算法
• 业务规则：频率控制、负反馈

阶段五：系统与工程（3 分钟）

• 数据流：Kafka + Flink + Feature Store
• A/B Test 框架
• 冷启动处理
• 监控：CTR、多样性、覆盖率

常见追问

关键知识点总结