想象你搬进一个陌生社区，今晚想吃顿好的却不知去哪家馆子。你会怎么做？绝不会挨家挨户敲一百户门，而是先锁定几个口味跟你一拍即合的邻居——你爱吃辣，就别问嗜糖如命的住户。请他们指路，综合几家意见，最终敲定目标。这就是“基于邻域的推荐”最朴素的直觉：物以类聚，人以群分。 在推荐系统里，这个“社区”就是成千上万的用户与物品，每个人的口味被记录成一份评分档案，铺开在“口味空间”中。KNN（K近邻）算法像一位热心的物业管家，替你在高维空间里画一个圈，圈出 K 个口味最像的邻居，再综合他们的评价给出推荐。这篇文章会带你把“怎么找邻居”“邻居意见如何加权”“社区太大怎么办”“推荐准不准怎么量”这条链路完整拆解，让你既懂原理，也懂工程落地。

岗位关联

掌握基于邻域的推荐与 KNN 优化，是进入推荐系统领域的必修课。它能帮你快速搭建可解释的召回/排序基线，理解相似度度量与稀疏处理的工程技巧，是晋升推荐算法工程师的重要阶梯。

目录
  1. 可视化演示
  2. 邻域推荐基础
  3. 相似度度量
  4. KNN推荐原理
  5. 性能特性分析
  6. 优化策略
  7. 实践与评估
  8. AI 应用场景
  9. Python 演示
  10. 常见误区
  11. 面试题

可视化演示

展示User-CF与Item-CF推荐机制、KNN近邻选择优化及相似度计算方法（余弦/皮尔逊/杰卡德），含星座网络背景和发光动画。

本节配有交互动效（进入视口后自动加载，约 3KB）。

邻域推荐基础

新住户打听餐馆，最靠谱的做法是看“邻里互助榜”——谁爱吃什么、给哪家店打过几星，全都记录在案。推荐系统也有这么一张榜，只是把它抽象成了一张冷冰冰却信息量巨大的表格，名叫“用户-物品评分矩阵”。

这张矩阵的行是一位位住户（用户），列是一家家店铺（物品），格子里填的是打分。用户 3 给物品 5 打了 4 分，就记作 \(r_{35}=4\)。绝大多数格子是空的，因为没人能尝遍全城每家馆子，这些空格记为 0，代表“没吃过的店”。基于这张矩阵，衍生出两条路线：基于用户的协同过滤（UserCF），即“问跟你口味像的邻居”；基于物品的协同过滤（ItemCF），即“看看你常去的店，和哪些店常被同一批食客光顾”。

推荐系统的核心目标，就是预测空格里“如果这位住户去那家店，会给几星”，从而把高星预测的店排进推荐清单。

回到社区的故事：这张评分矩阵就是社区的口味地图。地图越完整，推荐越准；地图上大片空白，推荐就会“两眼一抹黑”。UserCF 与 ItemCF 的区别，说白了就是“问人”还是“问店”——前者看谁和你像，后者看这家店像谁。

Rm×n=[r11⋯r1n⋮⋱⋮rm1⋯rmn],rui∈{0,1,2,3,4,5}R_{m \times n} = \begin{bmatrix} r_{11} & \cdots & r_{1n} \\ \vdots & \ddots & \vdots \\ r_{m1} & \cdots & r_{mn} \end{bmatrix}, \qquad r_{ui} \in \{0,1,2,3,4,5\}
这是整座“口味地图”的原始存档：行是住户，列是餐馆，数字是星级，0 表示还没去过。后面所有算法都在这张表上做文章。
  1. 矩阵行列评分矩阵有 m 行 n 列，行代表用户，列代表物品，每个格子就是一位用户给一件物品的打分记录。
    Rm×nR_{m \times n}
  2. 元素含义\(r_{ui}\) 表示第 u 位用户对第 i 件物品的评分，比如 \(r_{35}=4\) 就读作“用户 3 给物品 5 打了 4 分”。
    rui∈{0,1,2,3,4,5}r_{ui} \in \{0,1,2,3,4,5\}
  3. 零值含义0 不代表“差评”，而是“没评过”。正是这些大量存在的空格，构成了后面要反复面对的稀疏性问题。
    rui=0⟺未评分r_{ui} = 0 \quad \Longleftrightarrow \quad \text{未评分}

相似度度量

有了评分档案，下一个问题是：怎么判断两个邻居“口味像不像”？住得近不代表口味近——你家隔壁是甜品控，你却是麻辣党。要比较口味，得看他们光顾的馆子重合度有多高、打分倾向是否一致。

余弦相似度是最常用的“口味方向计”。它把每位用户的评分向量看作从原点射出的一支箭，箭的方向代表口味偏好。两个方向夹角越小，说明两人越“志同道合”。计算公式只取两人都评过分的物品，把评分数值代入向量的点积公式。

$

\text{sim}(u,v) = \cos(\vec{r}_u, \vec{r}_v) = \frac{\sum_{i \in I_{uv}} r_{ui} \cdot r_{vi}}{\sqrt{\sum_{i \in I_{uv}} r_{ui}^2} \cdot \sqrt{\sum_{i \in I_{uv}} r_{vi}^2}}

$

1. 共同评分集合：\(I_{uv}\) 表示用户 u 和用户 v 都评过分的物品集合。分子分母只在这个交集上计算，避免用“你没吃过我吃过”的数据硬比。

Iuv={i∣rui>0 且 rvi>0}I_{uv} = \{i \mid r_{ui} > 0 \text{ 且 } r_{vi} > 0\}

2. 分子点积：把两人对同一批物品的评分逐项相乘再求和。两人口味一致时，高分对高分、低分对低分，乘积自然大。

∑i∈Iuvrui⋅rvi\sum_{i \in I_{uv}} r_{ui} \cdot r_{vi}

3. 分母模长：各自评分向量的长度相乘，起到归一化作用，消除“有人手松全打 5 分，有人手紧只给 3 分”造成的尺度差异。

∑i∈Iuvrui2⋅∑i∈Iuvrvi2\sqrt{\sum_{i \in I_{uv}} r_{ui}^2} \cdot \sqrt{\sum_{i \in I_{uv}} r_{vi}^2}

4. 结果范围：相似度越接近 1，口味越同向；趋近 0，则基本无交集。

sim(u,v)∈[0,1]\text{sim}(u,v) \in [0,1]

除了余弦，还有两个常见变体：皮尔逊相关系数先把每位用户的评分减去其均值（中心化），再算余弦，这样能进一步抵消“手松手紧”的偏差；杰卡德系数干脆只看“共同评过分的物品数占两人评过分总数量的比例”，适合没有评分只有点击/购买这类 0-1 行为的场景。回到社区，这一步是在筛选“问路名单”——先把和你口味方向最一致的那批邻居排出来。

KNN推荐原理

名单有了，接下来要“集思广益”。假设你锁定了 K 个口味最像的邻居，怎么把他们的意见合成一个推荐分数？如果简单平均，会遇到两个尴尬：一是邻居里有人只是“有点像”，他的意见不该和别人同等分量；二是每个人的打分基准不同——有人常年给 5 星，有人最高只给 3 星，直接用原始分平均会失真。

KNN 的聪明做法是均值偏移加权。先看每个邻居对这个物品的评分，减去邻居自己的平均分，得到“净增益”——好比邻居说“这家店比我平时去的店好 0.5 分”。这个净增益再用相似度加权，相似的邻居权重更大。最后加回你自己的平均分，还原成预测评分。

算出所有未评分物品的预测分后，按分数降序排列，取前 N 个就是 TopN 推荐。这个过程好比先请一圈靠谱邻居打分，再把各家预测分排序，挑出口碑最好的几家店推给你。邻居选得好、K 值调得准，推荐质量就高。

r^ui=rˉu+∑v∈NK(u)sim(u,v)⋅(rvi−rˉv)∑v∈NK(u)∣sim(u,v)∣\hat{r}_{ui} = \bar{r}_u + \frac{\sum_{v \in \mathcal{N}_K(u)} \text{sim}(u,v) \cdot (r_{vi} - \bar{r}_v)}{\sum_{v \in \mathcal{N}_K(u)} |\text{sim}(u,v)|}
这是 KNN 推荐的“加权表决公式”：每个邻居投出一张“口味偏移票”，票的分量由相似度决定，最后加回你自己的基准分，得到对目标物品的预测评分。
  1. 邻居集合\(\mathcal{N}_K(u)\) 是用户 u 相似度最高的 K 个用户组成的邻居集合。K 越大，队伍越长，但杂音也可能越多。
    NK(u)={v1,v2,…,vK}\mathcal{N}_K(u) = \{v_1, v_2, \ldots, v_K \}
  2. 邻居偏移\(r_{vi} - \bar{r}_v\) 表示邻居 v 对物品 i 的评分相对他自己平均分的偏移。正数代表“他比平时更爱这家”，负数代表“他平时更挑剔”。
    rvi−rˉvr_{vi} - \bar{r}_v
  3. 加权求和每个偏移乘以 sim(u,v)，相似度高的邻居说话更有分量，不相似的邻居意见被压下去。
    ∑v∈NK(u)sim(u,v)⋅(rvi−rˉv)\sum_{v \in \mathcal{N}_K(u)} \text{sim}(u,v) \cdot (r_{vi} - \bar{r}_v)
  4. 归一化与回加除以权重总和让偏移回到原尺度，最后加上 \(\bar{r}_u\)，把预测值“锚定”在用户自己的评分习惯上。
    r^ui=rˉu+∑sim⋅偏移∑∣sim∣\hat{r}_{ui} = \bar{r}_u + \frac{\sum \text{sim} \cdot \text{偏移}}{\sum |\text{sim}|}

性能特性分析

社区只有几十户时，挨个问邻居毫无压力。可当“推荐小镇”膨胀到百万住户、千万家店铺时，物业想给每位住户找 K 个邻居，就要先算一张“住户 × 住户”的相似度关系网——这是一个惊人的计算量。

设用户数为 \(n\)、物品数为 \(m\)，构建完整相似度矩阵需要两两用户配对，每一对又要扫描共同评分的物品，总复杂度约 \(O(n^2 \cdot m)\)。百万用户意味着约 \(5 \times 10^{11}\) 个配对数，即使每对只花 1 微秒，也要数天才能跑完。因此，基于邻域的推荐天然有可扩展性瓶颈。

更棘手的是两类数据问题：冷启动与稀疏性。新住户搬进来时档案是空的，没法算相似度，系统给不出任何推荐；老住户虽然历史多，但评分矩阵里的 0 实在太多——平均每位住户只去过几百家店，而全城有几万家，共同评分物品少得可怜，算出的相似度往往虚高失真。

这段话想说明：KNN 在原理上优美，但在大规模社区里“挨个问”不现实。冷启动的新住户没人认识，稀疏的口味档案让相似度成了“薛定谔的数值”。要落地，必须上优化手段。

T(n,m)=O(n2⋅m)T(n, m) = O(n^2 \cdot m)
复杂度公式告诉你：用户数 n 翻一倍，计算量直接变成四倍。这就是“挨家挨户问全城”不可行的数学根源。
  1. 两两配对n 个用户两两组合，配对数约为 \(n(n-1)/2\)，数量级是 \(n^2\)。
    (n2)=n(n−1)2≈O(n2)\binom{n}{2} = \frac{n(n-1)}{2} \approx O(n^2)
  2. 每对扫描每一对用户计算相似度时，需要遍历 m 个物品找出共同评分项，乘上物品维度 m。
    n2×mn^2 \times m
  3. 平方增长用户数上升时，计算量呈平方级爆炸，远超线性扩展的能力边界。
    O(n2⋅m)≫O(n⋅m)O(n^2 \cdot m) \gg O(n \cdot m)

优化策略

既然“挨个问全城”不现实，物业想出了三种提速方案：分组、精筛、预计算。

第一招是聚类加速。把口味相近的住户先粗分成若干兴趣组团，找邻居时只在目标住户所在的组团内搜索，不用在全城范围内两两比较。组团内住户数量骤减，计算量从 \(n^2\) 降到“组团规模平方 × 组团数”。

第二招是降维处理，用矩阵分解给口味档案“做摘要”。把庞大的评分矩阵 \(R\) 分解成两个小矩阵的乘积，让每个用户和每件物品都浓缩成几十维的“隐因子”向量。之后相似度计算就在低维稠密空间进行，既降噪又提速。

第三招是局部敏感哈希（LSH）。它给每位住户的口味向量算一串哈希值，让口味接近的人大概率“撞进”同一个桶。搜索时只查目标桶，用很小的近似损失换来了数量级的加速。配合离线预计算——相似度矩阵在夜间定时算好存起来，线上服务时直接查表取邻居，毫秒级响应。

回到社区：聚类是“先组团再问路”，降维是“只记几个关键口味标签代替整本档案”，LSH 是“口音相近的人分到同层楼道”。三招齐下，百万人的大社区也能做到秒级找邻居。

Rm×n≈Um×k Σk×k Vk×n⊤,k≪min⁡(m,n)R_{m \times n} \approx U_{m \times k} \, \Sigma_{k \times k} \, V^\top_{k \times n}, \qquad k \ll \min(m, n)
矩阵分解把一张千万级的大表，压成两张 k 维的小表。k 越大信息越全，k 越小速度越快，本质是“用精度换速度”。
  1. 矩阵分解原始评分矩阵被拆成三个小矩阵的乘积，\(U\) 描述用户的隐因子偏好，\(V\) 描述物品的隐因子属性。
    R≈UΣV⊤R \approx U \Sigma V^\top
  2. 隐因子维度k 是隐因子个数，通常取几十到几百，远远小于用户数 m 和物品数 n。
    k≪min⁡(m,n)k \ll \min(m, n)
  3. 近似重构乘积得到的矩阵是对原矩阵的低秩近似，用每个用户和物品的低维向量内积预测未知评分，替代原始稀疏特征。
    r^ui=u⃗u⋅v⃗i\hat{r}_{ui} = \vec{u}_u \cdot \vec{v}_i

实践与评估

推荐系统做得好不好，不能靠拍脑袋，要用“考卷”说话。做法是：把用户已打过的分藏起一部分当作标准答案，让模型去猜，猜得越准，说明推荐能力越强。这套标准答案就是测试集，打分工具常用 RMSE（均方根误差）。

RMSE 的计算逻辑非常直觉：把每个“被藏起来”的真实评分与模型预测分相减，得到误差；误差平方后取平均，再开根号。平方的意义是放大那些离谱的大误差——预测差 2 分比差 0.2 分要严重得多，RMSE 会让它付出“四倍代价”。RMSE 越低，预测越贴近用户真实口味。

实践中，业界常用 MovieLens 数据集作为练手基准：6000 用户对近 4000 部电影给出 100 万条评分。工程师在这个标准考卷上对比不同 K 值、不同相似度计算的 RMSE，用交叉验证挑选最优超参。K 太小，只靠少数几个邻居容易以偏概全；K 太大，弱相关邻居混进来把预测“稀释”——通常 K 落在 10~50 之间表现较好。

社区的故事到这里闭合了：先画口味地图，再找相似邻居，加权综合意见，最后用标准考卷检验推荐准不准。一个可靠的 KNN 推荐系统，正是在“问对邻居”和“不断复盘考分”之间打磨出来的。

RMSE=1∣T∣∑(u,i)∈T(rui−r^ui)2RMSE = \sqrt{\frac{1}{|\mathcal{T}|} \sum_{(u,i) \in \mathcal{T}} (r_{ui} - \hat{r}_{ui})^2}
RMSE 是推荐系统的“考试分数”：把被隐藏的真实评分和模型预测分做差、平方、平均、开方，最终得到一个和评分同一量纲的误差值。越低越好。
  1. 测试集\(\mathcal{T}\) 是留出的评分集合，里面的真实评分对模型保密，只作评分依据。
    T={(u,i)∣rui 被隐藏}\mathcal{T} = \{(u,i) \mid r_{ui} \text{ 被隐藏}\}
  2. 预测误差真实分与预测分之差 \(r_{ui} - \hat{r}_{ui}\)，正误差代表预测高了，负误差代表预测低了。
    eui=rui−r^uie_{ui} = r_{ui} - \hat{r}_{ui}
  3. 平方平均所有误差平方后取平均，大误差被平方放大，模型不敢在个别样本上犯大错。
    1∣T∣∑(u,i)∈Teui2\frac{1}{|\mathcal{T}|} \sum_{(u,i) \in \mathcal{T}} e_{ui}^2
  4. 开根号恢复成评分原量纲，方便与 1~5 星的评分标准直接对照。
    1∣T∣∑eui2\sqrt{\frac{1}{|\mathcal{T}|} \sum e_{ui}^2}

AI 应用场景

电商平台的“猜你喜欢”

阶段：召回阶段

解决的问题：传统电商靠热门榜单推相同商品，忽略每个用户的个性化口味。基于邻域的 KNN 协同过滤用“和你购买行为相似的用户还买了什么”来召回候选商品，把推荐从“千篇一律”变成“一人千面”。

具体案例：Amazon 的 “Customers who bought this item also bought“ 就是基于物品的协同过滤典范。当你在浏览一台相机时，系统立刻找出”买过这台相机的人还买了哪些镜头和存储卡”，以打包形式呈现，大幅提升连带购买率。

短视频平台的兴趣探索

阶段：候选生成与粗排阶段

解决的问题：短视频平台上新内容海量涌入，完全靠深度学习精排成本过高。先用基于邻域的 KNN 从“和你口味相似的用户互动过的视频”中捞一批候选，再交给精排模型，兼顾速度与个性化。

具体案例：某短视频 App 对冷启动用户（无历史行为）先用热门内容和地域邻居的偏好做兜底推荐，积累一定互动后切换到 UserCF 召回，视频完播率提升 12%。

社交平台的“你可能认识的人”

阶段：召回与打分阶段

解决的问题：社交平台判断两个人是否认识，传统方式只数共同好友数，忽略互动强度。借鉴邻域思想，把“共同好友覆盖比例 + 互动频率”构造成一个多维相似度，用 KNN 找出潜在好友。

具体案例：LinkedIn 的 "People You May Know" 利用第二度连接关系（你认识的人还认识谁），结合职业标签相似度做邻域过滤，把高相似度的陌生人推荐给你，显著提升人脉连接率。

Python 演示

python85 行
import numpy as np class UserKNN:    """基于用户的KNN协同过滤推荐器, 输入用户-物品评分矩阵, 行为用户列为物品"""     def __init__(self, k=10):        self.k = k        self.rating_matrix = None        self.similarity_matrix = None        self.user_means = None     def fit(self, rating_matrix):        """训练模型: 计算每个用户的平均分和用户间余弦相似度"""        self.rating_matrix = rating_matrix.astype(float)        n_users = self.rating_matrix.shape[0]        self.user_means = np.array([            self.rating_matrix[u][self.rating_matrix[u] > 0].mean()            if (self.rating_matrix[u] > 0).any() else 0.0            for u in range(n_users)        ])        n = self.rating_matrix.shape[0]        self.similarity_matrix = np.zeros((n, n))        for u in range(n):            for v in range(u + 1, n):                sim = self._cosine_similarity(u, v)                self.similarity_matrix[u][v] = sim                self.similarity_matrix[v][u] = sim        return self     def _cosine_similarity(self, u, v):        """只计算两人共同评过分的物品上的余弦相似度"""        mask = (self.rating_matrix[u] > 0) & (self.rating_matrix[v] > 0)        if mask.sum() == 0:            return 0.0        xu = self.rating_matrix[u][mask]        xv = self.rating_matrix[v][mask]        denom = np.linalg.norm(xu) * np.linalg.norm(xv)        if denom == 0:            return 0.0        return np.dot(xu, xv) / denom     def predict(self, user, item):        """预测用户user对物品item的评分, 用均值偏移加权"""        if self.rating_matrix is None:            raise ValueError('请先调用 fit() 训练模型')        sims = self.similarity_matrix[user].copy()        rated = self.rating_matrix[:, item] > 0        sims[~rated] = -1        top_idx = np.argsort(sims)[::-1][:self.k]        top_k = [(i, sims[i]) for i in top_idx if sims[i] > 0]        if not top_k:            return self.user_means[user]        total = sum(sim for _, sim in top_k)        if total == 0:            return self.user_means[user]        pred = self.user_means[user] + sum(            (self.rating_matrix[i][item] - self.user_means[i]) * sim            for i, sim in top_k        ) / total        return max(1.0, min(5.0, pred))     def recommend(self, user, top_n=5):        """给用户产出TopN推荐列表"""        n_items = self.rating_matrix.shape[1]        scores = []        for item in range(n_items):            if self.rating_matrix[user][item] > 0:                continue            scores.append((item, self.predict(user, item)))        scores.sort(key=lambda x: x[1], reverse=True)        return scores[:top_n] if __name__ == '__main__':    R = np.array([        [5, 3, 0, 1, 4],        [4, 0, 0, 1, 3],        [1, 1, 0, 5, 0],        [1, 0, 0, 4, 2],        [0, 1, 5, 4, 0],        [2, 2, 0, 3, 1],    ])    model = UserKNN(k=2)    model.fit(R)    print('用户0对电影3的预测评分:', round(model.predict(0, 3), 2))    print('用户0的Top3推荐:', model.recommend(0, 3))
目的：实现一个完整的基于用户的 KNN 协同过滤推荐器，包括余弦相似度计算、K 近邻选取、均值偏移加权评分预测和 TopN 推荐。运行后能看到用户 0 对未看过的电影 3 的预测评分及推荐列表。
  1. self.rating_matrix[u][self.rating_matrix[u] > 0].mean()提取该用户所有非零评分的平均分，作为他的“打分习惯”
  2. mask = (self.rating_matrix[u] > 0) & (self.rating_matrix[v] > 0)只保留两人共同评过分的物品位置，避免拿“你吃过我没吃过”的店硬比
  3. return np.dot(xu, xv) / denom余弦相似度，衡量两份口味档案方向是否一致
  4. sims[~rated] = -1把没给目标物品打分的用户相似度压成负值，防止没尝过这家店的人混进邻居队伍
  5. top_idx = np.argsort(sims)[::-1][:self.k]按相似度从高到低排序，只取前 K 个作为邻居
  6. pred = self.user_means[user] + sum(...) / total在用户自己的评分基准上叠加邻居“口味偏移”，既尊重个人习惯又聚合群体智慧

常见误区

误区“K 越大，请教的邻居越多，意见越全面，推荐肯定越准。”初学者常以为邻居越多越好，把 K 从 5 调到 50，却发现预测越来越平庸。

正解K 值过大时，大量相似度很低的“弱邻居”混进决策圈，他们的意见像噪音一样把真正有价值的判断稀释掉。K 过小又会让结论过度依赖极少数人。社区里请教 100 个路人，不如认真问 10 个口味真正像你的朋友。实际使用需交叉验证，K 通常在 10~50 之间表现较好。

为何常见：“集思广益”的生活直觉被错误外推——大家以为样本越多统计越稳健，忽略了邻居质量比数量更关键。

误区“反正都是衡量相似度，用哪个都行。”有人发现余弦值低了，就换个欧氏距离试试，不理解两者本质差异。

正解余弦看的是评分向量的“方向”，只关心口味偏好结构；欧氏距离看的是数值的绝对间隔。比如用户 A 所有评分都是 5 分，用户 B 都是 3 分，两人余弦相似度可能很高（方向一致），欧氏距离却很大（数值差两档）。推荐场景应优先用余弦解决“手松手紧”问题，欧氏距离适合绝对量纲敏感的场合。

为何常见：两者都叫“相似度”，教材里又常混着出现，初学者没意识到“方向”和“距离”是两种几何直觉。

误区“神经网络都不用清洗数据，协同过滤应该更省事，直接喂原始评分矩阵就行。”

正解原始评分带上用户主观偏差，直接算相似度会失真。必须先做均值中心化或归一化，剔除“这个人是否手松”的影响；同时要过滤只有一两次评分的“低质量用户”，否则相似度会被偶然行为主导。社区里问路，也得先排除那个只吃过一家店就夸夸其谈的住户。

为何常见：评分矩阵看起来是整洁的数字表格，让人误以为可以直接进算法，忽略了数字背后的主观偏差。

误区“KNN 这么好用，所有场景直接套就行，冷启动根本不是问题。”

正解冷启动恰恰是 KNN 的先天短板。新用户没有评分历史，相似度无法计算，KNN 一个邻居都找不到。实践中必须搭配“热门兜底推荐”“内容特征冷启动”“探索性推荐”等策略，等用户攒够行为再切回 KNN。新住户刚搬来还没吃过一家店，你没法给他找“口味相似的邻居”。

为何常见：搞清楚了 KNN 的主流程，却忽略了它依赖历史数据这一前提，把基于邻域的方法当成万能药。

面试题

Q1. 基于邻域的推荐系统的核心假设是什么？

单选题 · easy

  • A.用户喜好随时间不断变化
  • B.物以类聚人以群分← 正确答案
  • C.评分越少的用户越可靠
  • D.所有物品之间彼此独立

答案：B。邻域推荐建立在一个朴素假设上：相似的用户有相似的偏好，相似物品会被相似人群喜欢，即“物以类聚，人以群分”。A 说的是兴趣漂移问题，C 与直觉相反，D 直接否定了物品关联的存在。

Q2. 两个用户没有任何共同评分物品时，他们的余弦相似度是？

单选题 · easy

  • A.1
  • B.-1
  • C.0← 正确答案
  • D.正无穷

答案：C。余弦相似度只在共同评分集合上计算。没有交集时，分子点积为 0，分母不为 0，相似度为 0，表示“没可比性”。1 表示完全一致，-1 表示完全相反，正无穷不可能出现。

Q3. KNN 推荐中，K 值过大会导致什么结果？

单选题 · easy

  • A.完全忽略所有邻居意见
  • B.只参考最相似的一个邻居
  • C.大量弱相关邻居稀释判断← 正确答案
  • D.相似度计算速度变快

答案：C。K 过大时，大量低相似度的“远房邻居”被拉进决策圈，意见像噪音一样把真正重要信号稀释掉，预测趋于平庸。K 过小才可能只参考极少数邻居，K 与计算速度无直接关系。

Q4. 皮尔逊相关系数与余弦相似度的关键区别是什么？

单选题 · mid

  • A.皮尔逊先做均值中心化← 正确答案
  • B.皮尔逊不需要任何评分
  • C.两者在数学上完全等价
  • D.皮尔逊只看评分数量

答案：A。皮尔逊相关系数先减去各自均值再计算，能抵消“手松打 5 分、手紧打 3 分”的评分习惯差异。余弦不中心化，等价于把原点放在(0,0)的皮尔逊。两者都依赖评分，数学上并非完全等价。

Q5. 基于物品的协同过滤比基于用户的协同过滤通常更稳定的原因是什么？

单选题 · mid

  • A.物品数量一定比用户数量少
  • B.物品的特征比用户变化更缓慢← 正确答案
  • C.物品评分一定都是整数
  • D.物品之间不需要计算相似度

答案：B。物品的属性相对稳定——一部电影的故事基调不会天天变，而用户的兴趣偏好会随心情和热点快速漂移。因此 ItemCF 的相似度矩阵更稳定，不用频繁更新。物品数量不一定更少，B 才是核心原因。

Q6. 用户-物品评分矩阵高度稀疏会带来哪些问题？

多选题 · hard

  • A.相似度计算因共同评分过少而失真← 正确答案
  • B.冷启动问题被进一步加剧← 正确答案
  • C.存储空间自动得到显著压缩
  • D.每个用户能找到的可靠邻居变少← 正确答案

答案：ABD。稀疏矩阵里两用户共同评分项极少，算出的相似度常虚高或不稳定；新用户行为少时更难匹配邻居；可靠邻居数量骤减。稀疏并不自动减少存储——矩阵结构仍要保存，计算量也不会自动下降，所以 C 错。

Q7. 下列哪些属于 KNN 推荐的工程优化手段？

多选题 · mid

  • A.离线预计算相似度矩阵← 正确答案
  • B.聚类后只在组内搜索邻居← 正确答案
  • C.把 K 值调整为无穷大
  • D.用局部敏感哈希加速近邻查找← 正确答案

答案：ABD。离线预计算让线上直接查表；聚类把搜索范围从全量用户缩小到兴趣组团；LSH 用哈希把相似用户撞进同桶加速查找。K 变成无穷大等于让全网用户参与投票，推荐质量灾难性下降，且并不加速。

Q8. 局部敏感哈希（LSH）加速 KNN 的核心思想是什么？

单选题 · hard

  • A.让相似向量大概率分到同一个桶← 正确答案
  • B.把每个用户和所有用户逐个比较
  • C.随机删除一半的评分数据
  • D.只用一个维度代表用户偏好

答案：A。LSH 通过巧妙设计哈希函数，使相似的向量以高概率碰撞到同一桶中，搜索时只检查目标桶即可找到大概率最近邻。它牺牲少量精度换取数量级的速度提升。B 是暴力搜索，C 会破坏数据，D 丢失信息过多。

Q9. 冷启动问题的本质原因是什么？

单选题 · mid

  • A.服务器磁盘空间不足
  • B.新用户或新物品没有历史交互数据← 正确答案
  • C.算法代码存在语法错误
  • D.用户数量太少无法构成社区

答案：B。基于邻域的推荐完全依赖历史交互来算相似度。新用户没评过分、新物品没被评过分，系统便无法定位邻居或相似物品。这与服务器资源、代码 bug 都无关，也和用户总数多少无直接关系。

Q10. 关于 KNN 预测中的均值偏移加权，说法正确的是？

多选题 · hard

  • A.用相似度作为每个邻居的权重← 正确答案
  • B.能抵消用户打分宽严不一致← 正确答案
  • C.所有邻居的评分一律平等平均
  • D.相似度为负的邻居也纳入加权

答案：AB。均值偏移加权先用邻居评分减去其个人均值得“净偏移”，再按相似度加权求和，最后加回目标用户均值，所以 A、B 正确。C 违背加权思想，D 错误——负相似度用户与目标口味相左，理应被排除在邻居集合之外。