机器学习与深度学习 / 系统课时

比较协同算法的覆盖与成本

比较协同算法的覆盖与成本

这一节把 UserCF、ItemCF 和 ALS 放到同一份训练集、同一个留出验证集和同一个候选数下比较。重点不是争论哪种算法“绝对更强”,而是同时观察召回率、覆盖率、训练成本和增量更新难度,得到可以用于工程选型的判断依据。

学习目标

  • 能在统一候选数和数据切分下比较三类协同算法
  • 能计算 Recall@K、Coverage@K 并正确解读训练耗时
  • 能结合增量更新方式判断 UserCF、ItemCF 与 ALS 的工程成本

先统一评估口径

比较算法时,最容易出现的错误是每个模型使用不同过滤规则、不同候选数或不同数据切分。这里统一采用“每个用户留出一个正样本”,推荐时过滤训练中已见物品,并固定 K=3。

Recall@3 统计留出的正样本有多少进入 Top-3;Coverage@3 统计所有用户的 Top-3 一共覆盖了多少不同物品,再除以物品总数。前者偏向命中能力,后者能发现模型是否总把流量集中到少数热门物品。

训练耗时只记录构建相似度矩阵或学习因子的阶段,不把评估循环算进去。这样三种算法的口径一致,但小样本的毫秒数只能验证代码路径,不能外推生产规模。

在同一数据集跑三种算法

下面的完整示例使用二值交互计算 UserCF 和 ItemCF 的余弦相似度,并使用相同训练矩阵训练隐式反馈 ALS。三种算法都通过同一个 evaluate 函数计算指标,避免评估逻辑悄悄发生变化。

python
import time
import numpy as np

R = np.array([
    [3, 2, 0, 0, 1, 0, 0, 0],
    [2, 0, 2, 0, 0, 1, 0, 0],
    [0, 3, 0, 2, 0, 0, 1, 0],
    [0, 0, 3, 2, 0, 0, 0, 1],
    [1, 0, 0, 0, 3, 2, 0, 0],
    [0, 1, 0, 0, 2, 0, 3, 0],
], dtype=float)

heldout = {0: 1, 1: 2, 2: 1, 3: 2, 4: 5, 5: 6}
train = R.copy()
for user_id, item_id in heldout.items():
    train[user_id, item_id] = 0.0
binary = (train > 0).astype(float)

def cosine_rows(matrix):
    norms = np.linalg.norm(matrix, axis=1, keepdims=True)
    denom = norms @ norms.T
    return np.divide(
        matrix @ matrix.T,
        denom,
        out=np.zeros((matrix.shape[0], matrix.shape[0])),
        where=denom > 0,
    )

def fit_usercf():
    similarity = cosine_rows(binary)
    np.fill_diagonal(similarity, 0.0)
    return similarity

def fit_itemcf():
    similarity = cosine_rows(binary.T)
    np.fill_diagonal(similarity, 0.0)
    return similarity

def fit_als(factors=4, reg=0.20, alpha=20.0, iterations=12, seed=7):
    rng = np.random.default_rng(seed)
    users, items = train.shape
    x = 0.1 * rng.normal(size=(users, factors))
    y = 0.1 * rng.normal(size=(items, factors))
    preference = binary
    confidence = 1.0 + alpha * train
    eye = np.eye(factors)

    for _ in range(iterations):
        yty = y.T @ y
        for u in range(users):
            c = confidence[u]
            a = yty + (y.T * (c - 1.0)) @ y + reg * eye
            x[u] = np.linalg.solve(a, y.T @ (c * preference[u]))

        xtx = x.T @ x
        for i in range(items):
            c = confidence[:, i]
            a = xtx + (x.T * (c - 1.0)) @ x + reg * eye
            y[i] = np.linalg.solve(a, x.T @ (c * preference[:, i]))
    return x, y

def evaluate(recommend, k=3):
    hits = 0
    recommended_items = set()
    for u, target in heldout.items():
        topk = recommend(u, k)
        hits += int(target in topk)
        recommended_items.update(topk.tolist())
    recall = hits / len(heldout)
    coverage = len(recommended_items) / train.shape[1]
    return recall, coverage

def benchmark(name, fit, build_recommender):
    started = time.perf_counter()
    model = fit()
    train_ms = (time.perf_counter() - started) * 1000
    recall, coverage = evaluate(build_recommender(model))
    print(
        f"{name}: Recall@3={recall:.3f}, "
        f"Coverage@3={coverage:.3f}, train_ms={train_ms:.3f}"
    )

def usercf_recommender(similarity):
    def recommend(u, k):
        scores = similarity[u] @ binary
        scores[train[u] > 0] = -np.inf
        return np.argsort(-scores)[:k]
    return recommend

def itemcf_recommender(similarity):
    def recommend(u, k):
        scores = binary[u] @ similarity
        scores[train[u] > 0] = -np.inf
        return np.argsort(-scores)[:k]
    return recommend

def als_recommender(model):
    x, y = model
    def recommend(u, k):
        scores = x[u] @ y.T
        scores[train[u] > 0] = -np.inf
        return np.argsort(-scores)[:k]
    return recommend

benchmark("UserCF", fit_usercf, usercf_recommender)
benchmark("ItemCF", fit_itemcf, itemcf_recommender)
benchmark("ALS", fit_als, als_recommender)

预期输出

text
UserCF: Recall@3=0.500, Coverage@3=1.000, train_ms=<TIME>
ItemCF: Recall@3=0.500, Coverage@3=1.000, train_ms=<TIME>
ALS: Recall@3=0.667, Coverage@3=0.875, train_ms=<TIME>

<TIME> 是动态值,会随 CPU、BLAS 实现和系统负载变化。这个示例中 ALS 的验证召回更高,但覆盖率低于两种 CF;数据集只有 6 个用户和 8 个物品,因此这些数值只用于验证评估方法,不能直接作为真实业务的算法优劣结论。

把指标和工程代价放在一起

算法 主要离线产物 这个示例的 Recall@3 这个示例的 Coverage@3 增量更新难度
UserCF 用户相似度或近邻表 0.500 1.000 较高,活跃用户变化会影响用户近邻
ItemCF 物品相似度或近邻表 0.500 1.000 较低到中等,物品关系通常比用户关系稳定
ALS 用户因子与物品因子 0.667 0.875 中等到较高,需要更新因子或周期重训

UserCF 的优势是解释直观:找到相似用户,再聚合邻居喜欢的物品。但用户规模和活跃行为快速增长时,相似度维护会变重,新用户也缺少足够邻居。

ItemCF 更适合“物品集合相对稳定、用户行为持续到来”的场景。一次新的用户行为可以立刻通过已有物品近邻产生候选,而物品相似度可以按批次更新,因此常见于需要简单、稳定增量链路的系统。

ALS 把稀疏交互压缩为定长向量,候选阶段可以接向量检索或批量点积,规模化后通常更容易控制存储结构。但新用户需要根据已有物品因子做 fold-in 或等待训练,新物品没有交互时也无法凭协同信号直接得到可靠因子。

选型时不要只保留一个数字

离线选型至少要把召回、覆盖和资源成本放在同一张实验记录里,并固定数据时间窗、负采样或候选过滤规则、K 值和硬件环境。否则“更快”可能只是机器不同,“召回更高”也可能只是候选数更大。

如果系统需要低复杂度和快速行为响应,ItemCF 往往是很强的基线;用户关系本身具有业务价值时可以保留 UserCF;交互规模较大、希望使用稠密向量并愿意承担周期训练与因子更新成本时,再重点评估 ALS。最终决策应来自同一数据切分上的多指标实验和线上成本约束,而不是算法名称。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

比较协同算法的覆盖与成本

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通