ALS交替最小二乘：协同过滤算法

可视化演示

展示Seq2seq编码器将输入序列压缩为上下文向量，解码器基于上下文自回归生成多步预测的端到端过程，可切换编码、解码、完整流程三种模式观察。

矩阵分解原理

火锅店的评分表上，第 u 行第 i 列是顾客 u 对菜品 i 的打分。但大部分格子是空的，因为很少有顾客每道菜都尝过。大厨和口味经理决定换个思路：不直接填满大表，而是把大表“拆”成两张小表。一张是顾客口味表，记录每位顾客对“辣度、麻度、鲜度”等 k 个口味的偏好；另一张是菜品风味表，记录每道菜的 k 个风味标签。只要把两个向量的对应分量相乘再累加，就能估算出顾客对菜品的喜爱程度。

在数学上，这个稀疏的用户—物品评分矩阵记为 \(\mathbf{R}\)，大小为 \(m \times n\)；拆出来的顾客口味表叫用户因子矩阵 \(\mathbf{P}\)，大小为 \(m \times k\)；菜品风味表叫物品因子矩阵 \(\mathbf{Q}\)，大小为 \(n \times k\)。\(k\) 远小于 \(m\) 和 \(n\)，所以这种分解也叫低秩近似。由于隐因子是算法自动从行为中学出来的，不必人解释具体含义，因此它们又被称为“隐因子”。

回到火锅店：这道菜“辣度 4、麻度 2、鲜度 5”，顾客“爱吃辣、怕麻、爱鲜”，两者点积后得分很高，推荐就产生了。矩阵分解正是这样把“大而不全”的评分表，压缩成了两张人人都能算的小名片。

ALS交替优化

两张表应该怎么同时调？如果两位经理同时改，你等我、我等你会陷入僵局。ALS 的办法是“轮流来”：大厨先把所有菜品的风味标签定住，口味经理根据这些标签，用最小二乘为每位顾客计算一份最匹配的口味表；然后调过来，口味表固定，大厨再重新调整每道菜的标签。如此交替，每次只解一个简单的最小化问题，避免了一次性求解两个未知矩阵的复杂非凸问题。

用数学语言说，先固定 \(\mathbf{Q}\)，则 \(\mathbf{Q}\) 成了已知量，对每个用户 u 的目标变成一个只含 \(\mathbf{p}_u\) 的二次函数；它是最小二乘问题，有唯一闭合解。更新完所有用户的 \(\mathbf{p}_u\) 后，再固定 \(\mathbf{P}\)，同样求解每个物品的 \(\mathbf{q}_i\)。一轮轮交替下去，损失逐渐下降并收敛。

两位经理不需要一次性推出完美答案。只要大厨先给出“菜单特征初稿”，口味经理就能算出最优口味；口味一定，大厨又能修正菜单。如此循环几轮，两张表的匹配度越来越高，预测也越来越准。

损失函数推导

如何衡量“调得好不好”？老板引入了“差评平方”考核：预测和实际差 1 分，记 1 分惩罚；差 2 分，记 4 分；差得越多扣分越重。把所有有记录格子的平方误差加起来，就是模型的总误差。但光看误差还不够——如果两位经理为了讨好少数顾客，把特征值调得极端夸张，遇到没吃过的顾客就会乱预测。所以还要加一条“员工守则”：向量值不要太大，这就是正则项。

把平方误差和正则加到一起，就得到了 ALS 要优化的整体目标函数。其中第一个累加覆盖所有有观测评分的 \((u,i)\) 对，第二项和第三项分别约束用户向量和物品向量的大小。这个函数越小，说明模型对已知评分的拟合越好，同时泛化能力也有保障。

火锅店的“综合满意度考核”既看预测准不准，也看方案稳不稳。把这两点放进一个函数里，ALS 的一切迭代更新，都为了让这个分数不断下降。

隐式反馈处理

不是每道菜顾客都会留下评分。更多时候，他们只是进店转了一圈、在菜单前多停了几秒、或者默默涮完一整盘毛肚。这些行为没有“4分”或“5分”，但同样透露偏好。ALS 的隐式反馈版本，正是为这类数据而生：把“看过的菜”记为 1，“没看过的菜”记为 0，再用行为的强度给每个样本配上置信度权重，比如看了 10 分钟比看了 10 秒更可信。

加权后的目标函数中，每一项都乘上一个 \(c_{ui}\)。\(c_{ui}\) 越大，表示这个行为越强烈的样本越要被认真拟合；而 0 值样本也会以较小权重参与训练，让模型学会“没看不代表绝对讨厌”。这样，原来缺失的信息也能被利用起来。

顾客在菜单前停留越久，老板就越确信他喜欢这道菜。隐式反馈 ALS 正是通过这样的信心理念，把记不住的“路过”也变成推荐依据。

并行化实现

火锅店开了 100 家分店。如果大厨把菜品特征定好，每位顾客的口味估计就只跟顾客自己的数据有关，天然可以交给不同分店同时算。ALS 最迷人的地方就在这：固定 \(\mathbf{Q}\) 后，每个用户向量 \(\mathbf{p}_u\) 只依赖该用户的评分行和 \(\mathbf{Q}\)，彼此完全独立，因此可以按用户行把数据切分到不同机器并行更新；固定 \(\mathbf{P}\) 后，同理可以按物品列并行更新。

在 Spark 这样的分布式平台上，用户矩阵按行分区存储，物品矩阵作为广播变量发送到每个工作节点。每轮交替就是两次大规模并行求解：先并行更新所有用户向量，再重新分区、并行更新所有物品向量。用户向量的闭合解公式如下：

各分店算完自己负责的顾客后，把结果汇总，再广播新的菜品特征，进入下一轮。正是这种“分店并行、总部协调”的模式，让 ALS 能扛住上亿用户和上千万商品的数据规模。

部署与评估

因子矩阵训练好后，推荐系统进入落地阶段。对用户 u，把未交互过的物品 i 代入预测公式，得到 \(\hat{r}_{ui}\)，按预测分从高到低排出 Top-N 列表，就是最常见的离线推荐产出。上线后还得量化效果：把历史数据切出测试集，将预测分与真实分比较，计算 RMSE 等指标，衡量模型预测误差是否可接受。

RMSE 对“大偏差”尤其敏感，能清晰反映预测是否离谱。实践中还会配合精确率、召回率等排序指标评估推荐清单质量。模型也可以定期用新增行为数据增量更新，让推荐保持新鲜。

火锅店把“私人订制菜单”试运行两周，看回头客是否增加、差评是否减少，再用这些反馈回头调模型。部署与评估就是推荐系统的“试菜环节”，不断校准，直到每桌客人都觉得这菜单像为自己量身定制。

AI 应用场景

Python 演示

import numpy as np class ALS:    def __init__(self, k=5, _lambda=0.1, iterations=20):        self.k = k        self._lambda = _lambda        self.iterations = iterations        self.P = None        self.Q = None        self._loss = float('inf')     def fit(self, R):        m, n = R.shape        rng = np.random.default_rng(42)        self.P = rng.normal(size=(m, self.k))        self.Q = rng.normal(size=(n, self.k))        for it in range(self.iterations):            for u in range(m):                self.P[u] = self._solve(R[u], self.Q)            for i in range(n):                self.Q[i] = self._solve(R[:, i], self.P)            self._loss = self._compute_loss(R)            print(f"iter {it + 1}, loss {self._loss:.4f}")     def _solve(self, r, M):        idx = np.where(r != 0)[0]        if len(idx) == 0:            return np.zeros(self.k)        A = M[idx].T @ M[idx] + self._lambda * np.eye(self.k)        b = M[idx].T @ r[idx]        return np.linalg.solve(A, b)     def _compute_loss(self, R):        mask = R != 0        pred = self.P @ self.Q.T        err = (R[mask] - pred[mask]) ** 2        reg = self._lambda * (np.sum(self.P ** 2) + np.sum(self.Q ** 2))        return float(np.sqrt(np.mean(err)) + reg)     def predict(self, u, i):        return float(self.P[u] @ self.Q[i]) if __name__ == "__main__":    R = np.zeros((20, 15))    rng = np.random.default_rng(0)    for _ in range(80):        u, i = rng.integers(0, 20), rng.integers(0, 15)        R[u, i] = rng.integers(1, 6)    model = ALS(k=4, _lambda=0.1, iterations=15)    model.fit(R)    print("predict(0, 3):", model.predict(0, 3))

1. self.P[u] = self._solve(R[u], self.Q)固定物品矩阵，用最小二乘更新用户 u 的因子向量。
2. self.Q[i] = self._solve(R[:, i], self.P)固定用户矩阵，再更新物品 i 的因子向量。
3. idx = np.where(r != 0)[0]只选有记录的非零位置，跳过缺失项。
4. A = M[idx].T @ M[idx] + self._lambda * np.eye(self.k)构造带正则的线性方程组系数矩阵。
5. b = M[idx].T @ r[idx]构造线性方程组的右侧常数向量。
6. return np.linalg.solve(A, b)直接解出该向量的闭合最优解。
7. pred = self.P @ self.Q.T用两个因子矩阵重建完整的预测评分表。
8. err = (R[mask] - pred[mask]) ** 2只计算真实评分对应位置的平方误差。
9. reg = self._lambda * (np.sum(self.P ** 2) + np.sum(self.Q ** 2))累加用户和物品向量的正则惩罚。
10. model.fit(R); print("predict(0, 3):", model.predict(0, 3))训练模型并对缺失位置做预测。

常见误区

面试题