推荐系统实战：如何用Python快速计算7大深度学习评价指标（附代码）

最近在优化一个内容推荐模块时，我重新审视了模型评估的整个流程。很多刚入行的朋友容易陷入一个误区：把模型训练出来，看到损失函数下降就以为大功告成。但实际上，在推荐系统这个领域，模型的好坏，最终要靠业务效果说话。而业务效果，往往需要通过一系列精心设计的评价指标来量化。这些指标就像医生的听诊器，能告诉你模型哪里健康，哪里可能有“隐疾”。

今天，我们就抛开理论公式，直接进入实战。我会手把手带你用Python，从零开始计算推荐系统中最核心的七个评价指标。我们不会只停留在调用sklearn.metrics，而是会深入代码背后，理解每个指标在真实业务场景下的含义和陷阱。无论你是正在搭建第一个推荐系统的开发者，还是希望优化现有模型效果的数据科学家，这篇文章都能为你提供一套即拿即用的工具箱。

1. 环境准备与数据理解

在开始敲代码之前，我们需要一个清晰的战场。推荐系统的评估，核心是对比“模型预测的推荐列表”和“用户真实的行为反馈”。因此，我们的数据通常包含两个部分：测试集和模型预测结果。

假设我们正在为一个新闻App构建推荐系统。测试集中记录了1000个用户在某个时间段内真实点击过的新闻ID列表。同时，我们的模型为这1000个用户每人输出了一个长度为10的新闻推荐列表。我们的任务就是评估这10000条推荐（1000用户 * 10条/用户）的质量。

首先，我们准备一个极简的模拟数据环境。这里我推荐使用numpy和pandas来处理数据，用scikit-learn作为基础计算库，但关键部分的逻辑我们会自己实现，以确保你真正理解。

import numpy as np
import pandas as pd
from collections import defaultdict

# 设置随机种子保证结果可复现
np.random.seed(42)

# 模拟数据：1000个用户，每个用户有0-5个真实点击项
n_users = 1000
all_items = list(range(1, 501))  # 假设有500个不同的新闻项目

# 生成用户真实交互数据：{user_id: [item_id1, item_id2, ...]}
true_interactions = {}
for uid in range(n_users):
    # 随机决定该用户有多少个真实点击（0到5个）
    n_clicks = np.random.randint(0, 6)
    # 从所有项目中随机选择n_clicks个作为真实点击
    clicked_items = np.random.choice(all_items, size=n_clicks, replace=False).tolist()
    true_interactions[uid] = clicked_items

# 生成模型推荐数据：为每个用户推荐10个项目
# 这里模拟一个“还不错的”模型，推荐列表会包含部分真实项目，也包含一些未交互的项目
recommendations = {}
for uid in range(n_users):
    true_items = true_interactions[uid]
    # 模拟推荐逻辑：推荐列表由部分真实项目 + 随机项目组成
    n_true_in_rec = np.random.randint(0, min(4, len(true_items)+1))  # 推荐列表中包含的真实项目数
    true_in_rec = list(np.random.choice(true_items, size=n_true_in_rec, replace=False)) if true_items else []
    
    # 用随机项目补全推荐列表到10个
    remaining_slots = 10 - len(true_in_rec)
    # 从用户未点击的项目中随机选择
    unclicked_items = list(set(all_items) - set(true_items))
    false_in_rec = list(np.random.choice(unclicked_items, size=remaining_slots, replace=False))
    
    # 合并并确保顺序（模拟排名，这里简单拼接，实际模型会有得分排序）
    rec_list = true_in_rec + false_in_rec
    # 稍微打乱一下，模拟并非所有真实项目都排在最前
    np.random.shuffle(rec_list)
    recommendations[uid] = rec_list

print(f"模拟数据生成完毕。")
print(f"示例：用户0的真实点击：{true_interactions[0][:5]}...")
print(f"示例：用户0的推荐列表：{recommendations[0]}")

注意：在实际项目中，你的true_interactions可能来自离线测试集（历史点击日志），而recommendations则来自模型对测试集用户的预测输出。确保两者的用户ID是对齐的。

有了数据，我们就可以进入核心的指标计算环节了。我们将从最基础的分类指标开始，逐步深入到推荐系统特有的排序指标。

2. 基础分类指标：准确率、精确率与召回率

虽然推荐任务常常被看作排序问题，但其基础单元——一个项目是否被推荐给一个用户——仍然可以视为一个二分类预测（推荐/不推荐）。因此，分类领域的经典指标是我们评估的起点。理解它们之间的差异和权衡，是后续理解更复杂指标的关键。

2.1 准确率 (Accuracy)：最直观的“正确率”

准确率的定义非常直观：所有预测中，预测正确的比例。在推荐系统上下文中，我们可以把“为用户u推荐项目i”视为一个正例预测，把“不推荐项目i给用户u”视为负例预测。但这里有个巨大的陷阱：推荐系统的候选项目池往往非常庞大（百万甚至上亿），而用户真正交互的只是极少数。这导致了极端的类别不平衡。

如果我们用一个愚蠢的模型，它永远不给任何用户推荐任何项目，那么它的“不推荐”准确率会接近100%，但这显然是个无用的模型。因此，准确率在推荐系统中很少被用作核心评估指标，但它可以作为最基础的参考。

让我们计算一下全局准确率。我们需要为每个用户-项目对做出预测判断。

def calculate_accuracy(true_interactions, recommendations, all_items):
    """
    计算全局准确率。
    注意：此计算量巨大（用户数*项目数），仅适用于小规模演示或理解概念。
    实际评估中几乎不这样计算。
    """
    total_predictions = 0
    correct_predictions = 0
    
    for uid, true_items in true_interactions.items():
        rec_items = set(recommendations[uid])
        for item in all_items:
            # 模型预测：如果item在推荐列表中，则预测为“正”（会点击）
            prediction_is_positive = (item in rec_items)
            # 真实情况：如果item在用户真实点击中，则真实为“正”
            true_is_positive = (item in true_items)
            
            if prediction_is_positive == true_is_positive:
                correct_predictions += 1
            total_predictions += 1
    
    accuracy = correct_predictions / total_predictions if total_predictions > 0 else 0
    return accuracy

# 由于我们的all_items有500个，总预测对数为1000*500=50万，计算较慢。
# 我们用一个极简的例子来演示逻辑，实际评估请跳过此指标或采样计算。
print("由于准确率计算开销大且不实用，此处不执行。我们转向更实用的指标。")

正如你所见，直接计算准确率不切实际。我们更关心的是模型推荐出来的那些项目质量如何。这就引出了精确率(Precision)和召回率(Recall)。

2.2 精确率 (Precision) 与召回率 (Recall)：一对“冤家”

这两个指标需要放在一起看。它们都只关注“正例”（即用户可能感兴趣的项目），但角度不同。

• 精确率 (查准率)：我推荐的项目里，有多少是用户真的喜欢的？ 它衡量的是推荐结果的“纯度”或“相关性”。精确率高，意味着用户点开推荐列表，发现大部分都是自己感兴趣的内容，体验会很好。
• 召回率 (查全率)：用户喜欢的所有项目里，有多少被我推荐出来了？ 它衡量的是模型的“覆盖能力”或“发现能力”。召回率高，意味着系统能够把用户潜在的兴趣点尽可能地挖掘并呈现出来。

它们之间通常存在此消彼长的关系（Trade-off）。提高推荐列表长度（K），更容易覆盖到用户喜欢的项目（召回率上升），但也会混入更多不相关的项目（精确率下降）。反之，只推荐最有把握的少数几个项目（K很小），精确率会很高，但会漏掉很多用户可能也喜欢的项目（召回率低）。

让我们来计算在推荐列表长度K=10时的平均精确率和平均召回率。

def calculate_precision_recall_at_k(true_interactions, recommendations, k=10):
    """
    计算所有用户在推荐列表前k项上的平均精确率和平均召回率。
    """
    precisions = []
    recalls = []
    
    for uid, true_items in true_interactions.items():
        rec_items = recommendations[uid][:k]  # 取前k个推荐
        true_set = set(true_items)
        rec_set = set(rec_items)
        
        # 交集：既被推荐，又是用户真实喜欢的项目
        hit_set = true_set & rec_set
        
        # 用户级精确率: hits / k
        user_precision = len(hit_set) / k if k > 0 else 0
        # 用户级召回率: hits / (用户真实喜欢的项目总数)
        user_recall = len(hit_set) / len(true_set) if len(true_set) > 0 else 0
        
        precisions.append(user_precision)
        recalls.append(user_recall)
    
    # 对所有用户取平均
    avg_precision = np.mean(precisions)
    avg_recall = np.mean(recalls)
    
    return avg_precision, avg_recall, precisions, recalls

avg_prec, avg_rec, prec_list, rec_list = calculate_precision_recall_at_k(true_interactions, recommendations, k=10)
print(f"在 K=10 时：")
print(f"  平均精确率(P@10): {avg_prec:.4f}")
print(f"  平均召回率(R@10): {avg_rec:.4f}")

# 我们也可以观察不同K值下的变化趋势
k_values = [1, 3, 5, 10, 20]
print("\n不同推荐列表长度下的指标变化：")
print("K\t平均精确率\t平均召回率")
for k in k_values:
    # 注意：我们的模拟推荐列表只有10项，当K>10时，只按10算
    effective_k = min(k, 10)
    p, r, _, _ = calculate_precision_recall_at_k(true_interactions, recommendations, k=effective_k)
    print(f"{k}\t{p:.4f}\t\t{r:.4f}")

从输出结果中，你通常能看到随着K增大，精确率下降而召回率上升的趋势。这个简单的对照实验能帮你快速理解模型在“精准”和“全面”之间的平衡点在哪里。

2.3 F1 Score：精确率与召回率的调和平均

当你需要用一个数字来同时代表精确率和召回率时，F1 Score就派上用场了。它是精确率和召回率的调和平均数。调和平均数对极端值更敏感，只有当精确率和召回率都较高时，F1 Score才会高。这迫使模型必须同时兼顾两者。

def calculate_f1_score(precision, recall):
    """计算F1 Score。"""
    if precision + recall == 0:
        return 0
    return 2 * (precision * recall) / (precision + recall)

# 计算宏观平均F1（先计算每个用户的F1，再平均）
user_f1_scores = []
for p, r in zip(prec_list, rec_list):
    user_f1_scores.append(calculate_f1_score(p, r))
macro_f1 = np.mean(user_f1_scores)

# 计算微观平均F1（用总体的精确率和召回率计算）
micro_f1 = calculate_f1_score(avg_prec, avg_rec)

print(f"F1 Score (宏观平均): {macro_f1:.4f}")
print(f"F1 Score (微观平均): {micro_f1:.4f}")
print("注：宏观平均对每个用户平等看待；微观平均受活跃用户（真实交互多的用户）影响更大。")

在实际业务中，选择精确率、召回率还是F1作为核心指标，取决于你的业务目标。如果推荐位非常宝贵（如首屏Banner），需要确保点击率，那么精确率更重要。如果你想提升用户的探索发现感，增加使用时长，那么召回率可能更关键。而F1则是一个不错的综合平衡指标。

3. 推荐系统核心指标：命中率与平均精度均值

基础分类指标没有考虑推荐列表内的顺序。然而在信息流或商品列表中，排在第一位的项目和排在第十位的项目，其价值天差地别。接下来的指标，开始引入“位置”信息。

3.1 命中率 (Hits Ratio)：最朴素的“是否推荐中”

命中率，有时也叫Hit Rate@K，它可能是业务方最容易理解的指标：在给用户推荐的K个物品里，有没有包含他真正会点击的那个？ 计算时，只要命中一个，就算成功。

它的计算非常简单：统计测试集中，有多少用户的真实交互物品至少有一个出现在了推荐列表的前K位，然后除以总用户数。

def calculate_hits_ratio_at_k(true_interactions, recommendations, k=10):
    """
    计算命中率@K。
    """
    hit_count = 0
    total_users_with_interaction = 0
    
    for uid, true_items in true_interactions.items():
        if not true_items:  # 如果用户没有真实交互，跳过（或不跳过，取决于定义）
            continue
        total_users_with_interaction += 1
        rec_items = recommendations[uid][:k]
        rec_set = set(rec_items)
        # 检查是否有任何一个真实物品出现在推荐列表中
        if any(item in rec_set for item in true_items):
            hit_count += 1
    
    # 分母有两种常见选择：所有用户，或有真实交互的用户。这里采用后者，更严谨。
    hits_ratio = hit_count / total_users_with_interaction if total_users_with_interaction > 0 else 0
    return hits_ratio

hr_at_5 = calculate_hits_ratio_at_k(true_interactions, recommendations, k=5)
hr_at_10 = calculate_hits_ratio_at_k(true_interactions, recommendations, k=10)
print(f"命中率 HR@5: {hr_at_5:.4f}")
print(f"命中率 HR@10: {hr_at_10:.4f}")

命中率的优点是直观，但它有两个明显缺点：1) 没有区分命中一个和命中多个的区别；2) 没有考虑命中的物品在列表中的位置。排在第一和排在末尾，都算一次命中。

3.2 平均精度均值 (MAP)：兼顾顺序与全面的强力指标

为了克服命中率的缺陷，我们引入平均精度均值。这个名字有点绕，我们拆解一下：

1. 精度 (Precision) @ k：在推荐列表的前k个位置，计算精确率。
2. 平均精度 (Average Precision, AP)：对于一个用户，考虑其所有真实相关物品在推荐列表中的位置。每当在一个新的位置k命中一个相关物品时，我们计算一次Precision@k，然后将所有这些Precision@k值平均起来，就得到了该用户的AP。AP越高，说明相关物品不仅被推荐出来了，而且排名还比较靠前。
3. 平均精度均值 (Mean Average Precision, MAP)：对所有用户的AP值再取平均。

MAP是信息检索和推荐系统中最重要、最常用的指标之一，因为它同时考虑了召回率、精确率和排名顺序。

def calculate_ap_at_k(user_true_items, user_rec_list, k=10):
    """
    计算单个用户的Average Precision@K。
    """
    if not user_true_items:
        return 0.0
    
    # 将真实物品集合转换为set便于查找
    true_set = set(user_true_items)
    # 初始化变量
    hits = 0
    sum_precisions = 0.0
    
    for i, item in enumerate(user_rec_list[:k]):
        rank = i + 1  # 位置从1开始计数
        if item in true_set:
            hits += 1
            precision_at_rank = hits / rank
            sum_precisions += precision_at_rank
    
    # AP = 所有命中位置上的精度之和 / 用户真实相关物品总数（或命中总数，两种定义都有）
    # 这里采用更常见的定义：除以 min(真实相关物品数, k) 或 真实相关物品数。
    # 我们采用除以真实相关物品数的定义，这样对相关物品多的用户更公平。
    ap = sum_precisions / len(user_true_items) if user_true_items else 0
    # 另一种常见定义：除以命中数或min(真实数, k)，根据你的评估目标选择。
    # ap = sum_precisions / min(len(user_true_items), k)
    return ap

def calculate_map_at_k(true_interactions, recommendations, k=10):
    """
    计算所有用户的Mean Average Precision@K。
    """
    aps = []
    for uid, true_items in true_interactions.items():
        user_ap = calculate_ap_at_k(true_items, recommendations[uid], k)
        aps.append(user_ap)
    map_score = np.mean(aps)
    return map_score

map_at_10 = calculate_map_at_k(true_interactions, recommendations, k=10)
print(f"平均精度均值 MAP@10: {map_at_10:.4f}")

# 让我们通过一个极简例子来直观理解AP的计算
print("\n--- AP计算示例 ---")
example_true = [101, 203]
example_rec = [203, 999, 101, 888, 777]  # 相关物品203排第1，101排第3
print(f"真实相关物品: {example_true}")
print(f"推荐列表: {example_rec}")
print(f"计算 AP@5:")
print(f"  位置1: 物品203命中，当前累计命中数=1, Precision@1 = 1/1 = 1.0000")
print(f"  位置3: 物品101命中，当前累计命中数=2, Precision@3 = 2/3 ≈ 0.6667")
print(f"  AP = (1.0000 + 0.6667) / 2 (真实物品总数) = {0.83335:.4f}")
print(f"  代码计算结果: {calculate_ap_at_k(example_true, example_rec, k=5):.4f}")

从示例可以看出，如果相关物品都排在前面，AP值会很高。如果相关物品排在后面，即使最终命中了，AP值也会被拉低。因此，MAP强烈鼓励模型将相关物品排在推荐列表的前列。

4. 排序敏感指标：平均倒数排名与折损累计增益

有些场景下，我们尤其关心第一个相关物品出现的位置，或者希望给予列表中不同位置的项目以不同的权重。这时就需要MRR和NDCG登场了。

4.1 平均倒数排名 (MRR)：关注“第一个”命中

MRR的核心思想是：用户往往只看推荐列表的前几位。那么，第一个相关物品出现的位置越靠前，用户体验就越好。MRR计算的是这个位置的倒数的平均值。

• 倒数排名 (Reciprocal Rank, RR)：对于单个用户，找到其第一个相关物品在推荐列表中的位置rank，则该用户的RR = 1 / rank。如果列表中没有相关物品，则RR = 0。
• 平均倒数排名 (Mean Reciprocal Rank, MRR)：对所有用户的RR取平均值。

MRR特别适合评估问答系统或搜索系统，因为用户通常只关心第一个正确答案。在推荐系统中，如果业务场景是“为用户寻找当前最可能点击的一个首要项目”，MRR也很有用。

def calculate_mrr_at_k(true_interactions, recommendations, k=10):
    """
    计算平均倒数排名 MRR@K。
    """
    reciprocal_ranks = []
    
    for uid, true_items in true_interactions.items():
        if not true_items:
            continue  # 或无真实交互的用户RR记为0，取决于评估集定义
        rec_list = recommendations[uid][:k]
        true_set = set(true_items)
        
        rr = 0
        for i, item in enumerate(rec_list):
            if item in true_set:
                rr = 1.0 / (i + 1)  # 位置从1开始
                break  # 只关心第一个命中
        reciprocal_ranks.append(rr)
    
    mrr = np.mean(reciprocal_ranks) if reciprocal_ranks else 0
    return mrr

mrr_at_10 = calculate_mrr_at_k(true_interactions, recommendations, k=10)
print(f"平均倒数排名 MRR@10: {mrr_at_10:.4f}")

4.2 归一化折损累计增益 (NDCG)：最精细的排序评价

NDCG是评估排序列表质量的“黄金标准”，尤其在信息检索领域。它比MAP更进一步，不仅考虑物品是否相关，还考虑相关程度（分级相关性），并且通过一个折损函数，让排名靠后的项目贡献度递减。

其计算步骤如下：

1. 累计增益 (CG@K)：推荐列表前K个项目的相关性分数之和。不考虑顺序。
2. 折损累计增益 (DCG@K)：在CG的基础上，给每个位置赋予一个折损权重（通常为1 / log2(rank + 1)），排名越靠后，折损越大。这模拟了用户注意力随列表下降而衰减的现象。
3. 理想折损累计增益 (IDCG@K)：将用户所有相关物品按照相关性分数从高到低排序，取前K个计算出的DCG。这是理论上能达到的最佳DCG。
4. 归一化折损累计增益 (NDCG@K)：NDCG@K = DCG@K / IDCG@K。其值在0到1之间，1表示达到了理想排序。

在我们的模拟数据中，我们假设用户对物品的交互是二元的（点击/未点击），相关性分数就是1或0。在实际中，相关性可以是多级的（如评分1-5星）。

def calculate_ndcg_at_k(user_true_items, user_rec_list, k=10):
    """
    计算单个用户的NDCG@K（二元相关性）。
    """
    # 二元相关性：在真实交互列表中则为1，否则为0
    def rel(item):
        return 1 if item in user_true_items else 0
    
    # 计算DCG@K
    dcg = 0.0
    for i, item in enumerate(user_rec_list[:k]):
        rank = i + 1
        relevance = rel(item)
        # 最常用的DCG计算公式
        dcg += relevance / np.log2(rank + 1)
    
    # 计算IDCG@K：将真实相关物品全部排在前面
    # 首先，构建理想排序列表：前min(k, len(true_items))个位置全是相关物品(rel=1)，后面为0
    ideal_relevance = [1] * min(k, len(user_true_items))
    ideal_relevance.extend([0] * max(0, k - len(user_true_items)))
    
    idcg = 0.0
    for i, rel in enumerate(ideal_relevance):
        rank = i + 1
        idcg += rel / np.log2(rank + 1)
    
    # 计算NDCG
    ndcg = dcg / idcg if idcg > 0 else 0.0
    return ndcg

def calculate_avg_ndcg_at_k(true_interactions, recommendations, k=10):
    """
    计算所有用户的平均NDCG@K。
    """
    ndcg_list = []
    for uid, true_items in true_interactions.items():
        user_ndcg = calculate_ndcg_at_k(true_items, recommendations[uid], k)
        ndcg_list.append(user_ndcg)
    avg_ndcg = np.mean(ndcg_list)
    return avg_ndcg

avg_ndcg_at_10 = calculate_avg_ndcg_at_k(true_interactions, recommendations, k=10)
print(f"平均归一化折损累计增益 NDCG@10: {avg_ndcg_at_10:.4f}")

# 示例：理解DCG的折损
print("\n--- NDCG计算示例（二元相关性）---")
example_true = [101, 203, 307]
example_rec_good = [101, 203, 999, 307, 888]  # 相关物品都靠前
example_rec_bad = [999, 888, 101, 777, 203]   # 相关物品靠后
k=5
print(f"真实相关物品: {example_true}")
print(f"推荐列表A (好排序): {example_rec_good}")
print(f"推荐列表B (差排序): {example_rec_bad}")
print(f"NDCG@{k} for List A: {calculate_ndcg_at_k(example_true, example_rec_good, k):.4f}")
print(f"NDCG@{k} for List B: {calculate_ndcg_at_k(example_true, example_rec_bad, k):.4f}")

NDCG是综合性最强的指标，它同时考虑了相关性分级和位置折损。在工业级推荐系统中，NDCG及其变种（如考虑更多业务因素的加权NDCG）被广泛用于模型训练（作为损失函数）和离线评估。

5. 指标实战应用与综合对比

了解了每个指标的计算和含义后，我们面临一个现实问题：在项目中到底该用哪个？ 答案是：看场景，而且通常要结合多个指标一起看。

5.1 指标选择指南

不同的业务目标对应不同的核心指标。你可以参考下表进行选择：

业务场景与目标	推荐关注的指标	原因解析
优化点击率 (CTR)	精确率@K (P@K)	核心是保证推荐出来的条目尽可能都是用户想点的，提升单次曝光的点击概率。
提升内容覆盖率/发现性	召回率@K (R@K)	目标是让用户能看到更多他可能感兴趣的内容，即使有些不够精准，旨在挖掘长尾兴趣。
综合平衡精准与全面	F1 Score@K 或 MAP@K	当业务没有明显偏向时，需要一个综合指标。F1是P和R的调和，MAP则进一步考虑了排名。
首条推荐至关重要	MRR@K	信息流“第一条”或搜索“第一条结果”的场景，用户注意力高度集中于顶部。
优化整体列表体验	NDCG@K	最全面的排序指标，尤其适用于列表较长（如信息流）、用户会向下浏览的场景，能精细评估整个列表的质量。
快速验证推荐有效性	命中率@K (HR@K)	计算简单，结果直观，适合在项目初期快速验证模型是否“基本可用”。

5.2 综合评估示例与代码整合

在实际评估报告中，我们通常会计算一组指标，从不同角度描绘模型性能。下面是一个整合了上述所有指标的计算函数示例。

def evaluate_recommendation_system(true_interactions, recommendations, k_values=[1, 5, 10]):
    """
    对推荐系统进行多指标综合评估。
    """
    results = {}
    
    for k in k_values:
        print(f"\n=== 评估指标 @{k} ===")
        
        # 1. 精确率 & 召回率 & F1
        avg_prec, avg_rec, _, _ = calculate_precision_recall_at_k(true_interactions, recommendations, k)
        micro_f1 = calculate_f1_score(avg_prec, avg_rec)
        print(f"  精确率(P): {avg_prec:.4f}")
        print(f"  召回率(R): {avg_rec:.4f}")
        print(f"  F1 Score: {micro_f1:.4f}")
        
        # 2. 命中率
        hr = calculate_hits_ratio_at_k(true_interactions, recommendations, k)
        print(f"  命中率(HR): {hr:.4f}")
        
        # 3. MAP
        map_score = calculate_map_at_k(true_interactions, recommendations, k)
        print(f"  平均精度均值(MAP): {map_score:.4f}")
        
        # 4. MRR
        mrr = calculate_mrr_at_k(true_interactions, recommendations, k)
        print(f"  平均倒数排名(MRR): {mrr:.4f}")
        
        # 5. NDCG
        avg_ndcg = calculate_avg_ndcg_at_k(true_interactions, recommendations, k)
        print(f"  平均NDCG: {avg_ndcg:.4f}")
        
        results[k] = {
            'Precision': avg_prec,
            'Recall': avg_rec,
            'F1': micro_f1,
            'HR': hr,
            'MAP': map_score,
            'MRR': mrr,
            'NDCG': avg_ndcg
        }
    
    return results

# 执行综合评估
final_results = evaluate_recommendation_system(true_interactions, recommendations, k_values=[5, 10])

运行这段代码，你会得到模型在不同列表长度下的性能全景图。对比不同K值下的指标变化，可以帮助你决定产品中最佳的推荐列表长度。例如，如果P@5和P@10下降不多，但R@10显著高于R@5，那么也许将列表长度从5增加到10是值得的。

5.3 避坑指南：指标解读的常见陷阱

即使算对了指标，解读错误也会导致错误的决策。这里有三个我踩过的坑：

1. 忽略用户活跃度分布：如果评估集中大量用户只有极少甚至没有交互行为，那么召回率、MAP等指标会天然被拉低。此时，按用户分组（如高活跃、中活跃、低活跃）分别计算指标更有意义。
2. 离线与在线指标的鸿沟：离线指标（如NDCG）的提升，并不总能保证在线A/B测试的胜利。离线指标基于历史数据，无法完全模拟用户看到新推荐后的实时反馈和动态变化。离线指标是必要条件，而非充分条件。
3. 指标之间的虚假权衡：有时优化A指标会导致B指标下降，这未必是模型问题。例如，一个更“激进”的模型可能召回率很高但精确率一般，而一个“保守”的模型则相反。关键要看下降的幅度和业务容忍度。建立一个多指标综合看板，长期监控其变化趋势，比单点比较更重要。

最后，别忘了把这些评估函数封装成你项目中的evaluation.py模块。在模型迭代时，自动化地跑一遍评估流程，能让你对每一次优化效果都心中有数。评估不是一次性的任务，而是贯穿模型生命周期、驱动其持续优化的核心环节。