多样性

在热门排名系统中,多样性(Diversity)是确保用户体验和内容生态健康的关键因素。

什么是多样性

多样性指推荐结果在多个维度上的差异化程度:

  • 内容类型多样性:图文、视频、直播等不同形式
  • 主题多样性:不同话题、领域的覆盖
  • 创作者多样性:避免头部创作者垄断曝光
  • 时效多样性:新旧内容的合理分布
  • 热度多样性:热门与长尾内容的平衡

为什么需要多样性

用户层面

  1. 避免信息茧房:防止用户只看到相似内容
  2. 提升探索体验:帮助用户发现新的兴趣点
  3. 减少审美疲劳:同类内容连续出现会降低兴趣
  4. 满足多元需求:用户在同一时段可能有多种需求

平台层面

  1. 生态健康:给中腰部创作者曝光机会
  2. 内容消耗:避免热门内容过度消费
  3. 长期留存:多样性提升用户长期满意度

数据支撑

研究显示:
- 多样性提升 10%,用户停留时长增加 5-8%
- 过度同质化导致 7 日留存下降 15%
- 引入多样性后,内容消费广度提升 25%

多样性与相关性的权衡

核心矛盾

┌─────────────────────────────────────────────────────┐
│                  排序目标平衡                        │
├─────────────────────────────────────────────────────┤
│   相关性 ↑    多样性 ↑                              │
│   点击率 ↑    探索性 ↑                              │
│   短期满足    长期价值                              │
│   过度相关→信息茧房  过度多样→相关性下降            │
└─────────────────────────────────────────────────────┘

权衡策略

策略描述适用场景
硬约束强制保证最低多样性阈值冷启动、新用户
软约束目标函数中加入惩罚项成熟用户
动态调整根据用户行为实时调整全场景通用

多样性算法

1. MMR(Maximal Marginal Relevance)

特点:贪心选择,λ控制权重,复杂度 O(n²)

2. DPP(Determinantal Point Process)

特点:基于行列式的概率模型,复杂度 O(n³)

3. 基于聚类的多样性

MMR 和 DPP 都是在排序结果层面做多样性控制,而基于聚类的多样性是在候选集层面做的:先把候选内容按主题或语义聚成若干簇,再限制每个簇在结果中的占比。

它的优势是成本低、可解释、易于运营沟通。运营可以直接说「同一个话题最多出现两条」,而 MMR 的权重系数很难向业务方解释。

候选集
   │
   ▼
┌──────────────────────────┐
│ 语义向量 / 关键词抽取      │
└────────────┬─────────────┘
             ▼
┌──────────────────────────┐
│ 聚类(K-Means / 层次聚类) │  → 得到 topic_1, topic_2, ...
└────────────┬─────────────┘
             ▼
┌──────────────────────────┐
│ 每簇配额(cap)控制        │  → 每个簇最多保留 N 条
└────────────┬─────────────┘
             ▼
        按簇内热度排序 → 交错合并
from dataclasses import dataclass
from typing import Callable


@dataclass
class Cluster:
    """一个主题簇。"""
    cluster_id: int
    items: list
    label: str = ""


def cap_by_cluster(
    candidates: list,
    cluster_of: Callable,
    cap: int = 2,
    min_per_cluster: int = 0,
) -> list:
    """按簇配额过滤候选内容。

    cluster_of: 传入一个候选,返回它所属的簇 ID
    cap: 每个簇最多保留的条数
    min_per_cluster: 每个簇至少保留的条数(0 表示不强制保底)

    采用两遍扫描:
    - 第一遍为每个簇保留至多 min_per_cluster 条,保证小众话题有曝光;
    - 第二遍在剩余配额内按原始顺序填充。
    """
    counts = {}
    kept_indexes = set()

    if min_per_cluster > 0:
        for index, item in enumerate(candidates):
            cid = cluster_of(item)
            if counts.get(cid, 0) >= min_per_cluster:
                continue
            kept_indexes.add(index)
            counts[cid] = counts.get(cid, 0) + 1

    for index, item in enumerate(candidates):
        if index in kept_indexes:
            continue
        cid = cluster_of(item)
        if counts.get(cid, 0) >= cap:
            continue
        kept_indexes.add(index)
        counts[cid] = counts.get(cid, 0) + 1

    return [candidates[i] for i in sorted(kept_indexes)]


def interleave_by_cluster(candidates: list, cluster_of: Callable) -> list:
    """交错合并:轮流从各个簇中取一条,避免同簇内容相邻。

    这是多样性重排里很有效的一个小技巧——用户感知到的重复,
    很大程度上来自「连续看到两条同类内容」。
    """
    buckets = {}
    order = []
    for item in candidates:
        cid = cluster_of(item)
        if cid not in buckets:
            buckets[cid] = []
            order.append(cid)
        buckets[cid].append(item)

    result = []
    index = 0
    while len(result) < len(candidates):
        progressed = False
        for cid in order:
            bucket = buckets[cid]
            if index < len(bucket):
                result.append(bucket[index])
                progressed = True
        if not progressed:
            break
        index += 1

    return result

关键参数的取舍:

参数含义调整方向
簇数量 K划分得越细,约束越紧K 过大时几乎每个内容自成一簇,配额形同虚设
每簇配额 cap单簇最多保留条数调小更分散,但可能牺牲相关性
保底条数强制保留的每簇最小数量防止小众话题被完全挤出
聚类粒度语义簇 / 话题标签语义簇更准,话题标签更可控、更便宜

关于保底机制:纯粹的配额上限会产生一个副作用——如果候选集里某个话题特别热门,其他话题会被挤到后面很远的位置,用户短期内看不到。设置 min_per_cluster 可以保证每个话题至少有一点点曝光。但保底数量不宜设置过大,否则多样性约束会反过来伤害相关性。

聚类本身的成本。对候选集做 K-Means 是有开销的,优化方向包括:

  • 复用离线聚类结果。内容入库时就聚好类,在线直接读取标签,这是最常见的做法。
  • 增量聚类。新内容只与最近的几个已有簇中心比较,避免全量重聚。
  • 按召回通路分桶聚类。不同召回通路的内容天然有主题倾向,分桶后每桶的候选规模更小,聚类更快也更准。

4. 滑动窗口去重

滑动窗口去重是结果层的多样性控制:维护一个最近 N 条的窗口,窗口内同一类别(或同一作者)的内容不能超过阈值。与基于配额的方法相比,它不关心全局分布,只保证局部不重复,实现简单得多。

from collections import deque
from dataclasses import dataclass, field
from typing import Callable


@dataclass
class SlidingWindowDedup:
    """滑动窗口去重:窗口内同类内容数量受限。

    window_size: 窗口大小(保留最近多少条)
    max_per_key: 窗口内同一 key 允许的最大数量
    """

    window_size: int = 10
    max_per_key: int = 2
    window: deque = field(default_factory=deque)
    counts: dict = field(default_factory=dict)

    def allow(self, key: str) -> bool:
        """判断一条内容是否允许进入结果。

        允许则把它加入窗口并更新计数,否则直接丢弃。
        """
        current = self.counts.get(key, 0)
        if current >= self.max_per_key:
            return False

        self.window.append(key)
        self.counts[key] = current + 1

        # 窗口满了就淘汰最早的一条
        if len(self.window) > self.window_size:
            oldest = self.window.popleft()
            self.counts[oldest] -= 1
            if self.counts[oldest] <= 0:
                del self.counts[oldest]

        return True

    def filter(self, candidates: list, key_of: Callable) -> list:
        """对候选列表做滑动窗口去重。"""
        kept = []
        for item in candidates:
            if self.allow(key_of(item)):
                kept.append(item)
        return kept

参数怎么定:

参数取值过小取值过大
window_size约束只作用在极短范围内,用户仍会连续看到同类内容约束范围过大,多样性要求过高,内容供给不足
max_per_key同类内容几乎无法共存失去去重意义

一个常见的起点是窗口 10 条、同一类别最多 2 条。首屏 10 条里任何类别不超过 2 条,用户感知上的重复感会明显下降。这个取值需要用线上数据验证。

滑动窗口的三个工程要点:

  1. 窗口状态要跟着用户走。窗口是「当前用户已经看到的最近 N 条」,必须按用户维度维护,不能全局共享。可以用 Redis 的 List 结构配合 LTRIM 保留尾部元素。
  2. key 的粒度要合适。用一级类目做 key 太粗,用文章 ID 做 key 等于没去重。实践中常用「一级类目」或「作者」作为 key,两者可以组合成不同的通道。
  3. 被过滤的内容要计入计数吗。上面实现里,被过滤的内容不进入窗口。这个选择会让窗口只反映”实际展示的内容”,符合用户真实的感知。如果选择让被过滤的内容也计入窗口计数,约束会更严格,但可能导致结果偏少。

滑动窗口与配额方法的组合:配额控制的是全局分布,滑动窗口控制的是局部密度。两者目标不同,通常一起使用——先用配额保证整体结构,再用滑动窗口打散相邻位置。

多样性维度设计

内容特征:
  - 类型:图文、短视频、长视频、直播、音频
  - 主题:科技、娱乐、体育、财经、生活...
  - 长度:短 (&lt;1 分钟)、中 (1-5 分钟)、长 (>5 分钟)

创作者:
  - 层级:头部 (>100 万)、腰部 (10-100 万)、尾部 (&lt;10 万)
  - 类型:个人、机构、品牌官方、媒体

时间:
  - 时效:实时 (&lt;1h)、新鲜 (1-24h)、近期 (1-7 天)、经典 (>7 天)

实现架构

┌─────────────────────────────────────────────────────────┐
│                   多样性排序服务                         │
├─────────────────────────────────────────────────────────┤
│  ┌─────────┐    ┌─────────┐    ┌─────────┐             │
│  │ 候选生成 │ →  │ 多样性过滤│ →  │ 最终排序 │             │
│  │ Recall  │    │Diversity│    │Ranking  │             │
│  └─────────┘    └─────────┘    └─────────┘             │
│       ↓              ↓              ↓                   │
│  多路召回        MMR/DPP        精排模型               │
│  混合策略        规则过滤        多样性重排             │
└─────────────────────────────────────────────────────────┘

评估指标

多样性指标

指标说明
类别覆盖率出现类别数/总类别数
基尼系数衡量分布均匀度
熵值衡量分布不确定性
平均相似度衡量整体相似度
创作者集中度头部创作者曝光占比

综合评估

前面列的多样性指标各自只反映一个侧面。真正要回答的问题是「这批推荐结果整体好不好」,而这需要把相关性、多样性、时效性、质量等多个目标综合起来。

单一指标不够用的原因是它们之间存在冲突:类别覆盖率高的结果,相关性可能已经明显下降;而只看相关性,多样性低的缺陷又会被掩盖。综合评估要做的,就是把这些冲突显式地表达出来。

第一步:把每个目标归一化到同一量纲。 不同指标的取值范围和方向都不一样,必须先统一:

目标代表指标原始范围归一化方向归一化方法
相关性平均相关性得分0 到 1越大越好直接使用
多样性类别覆盖率0 到 1越大越好直接使用
多样性基尼系数0 到 1越小越好取 1 减去基尼系数
多样性平均相似度0 到 1越小越好取 1 减去相似度
时效性平均内容年龄(小时)0 到正无穷越小越好用指数映射到 0 到 1
质量平均完播或阅读完成率0 到 1越大越好直接使用

时效性的归一化需要特别注意:内容年龄没有天然上界,不能简单做线性截断。用指数衰减映射更合理:

a^=exp⁡(−aˉ/τ)\hat{a} = \exp(-\bar{a} / \tau)

其中 aˉ\bar{a} 是结果集的平均内容年龄,τ\tau 是时间常数,取值参考内容类型的半衰期设定。

第二步:加权合成。 综合得分为:

Q=∑kλk⋅s^kQ = \sum_{k} \lambda_k \cdot \hat{s}_k

其中 s^k\hat{s}_k 是第 kk 个目标的归一化得分,λk\lambda_k 是权重,满足 ∑kλk=1\sum_k \lambda_k = 1。

from dataclasses import dataclass
from math import exp
from statistics import mean


@dataclass(frozen=True)
class Objective:
    """一个评估目标。"""
    name: str
    weight: float
    value: float


class DiversityEvaluator:
    """结果集综合评估器。"""

    def __init__(self, time_constant_hours: float = 6.0):
        self.time_constant = time_constant_hours

    def normalize_age(self, average_age_hours: float) -> float:
        """时效性归一化:内容越新得分越高。"""
        if average_age_hours < 0:
            return 1.0
        return exp(-average_age_hours / self.time_constant)

    def normalize_gini(self, gini: float) -> float:
        """基尼系数归一化:分布越均匀得分越高。"""
        return 1.0 - max(0.0, min(1.0, gini))

    def composite_score(self, objectives: list) -> float:
        """计算综合得分。

        objectives 中的 value 必须已经归一化到 0 到 1。
        """
        total_weight = sum(o.weight for o in objectives)
        if total_weight <= 0:
            return 0.0
        return sum(o.weight * max(0.0, min(1.0, o.value)) for o in objectives) / total_weight

    def evaluate(self, result_set: list) -> dict:
        """对一个结果集做完整评估,返回各项得分与综合得分。

        result_set 中每个元素需要包含 category、author、relevance、
        age_hours、quality 五个字段。
        """
        if not result_set:
            return {"composite": 0.0}

        categories = [item["category"] for item in result_set]
        authors = [item["author"] for item in result_set]

        # 覆盖率应按「出现的类别数 / 候选池类别数」计算,
        # 这里用结果集内的类别数占结果集长度的比例作为近似
        category_coverage = len(set(categories)) / len(result_set)
        author_concentration = max((authors.count(a) for a in set(authors)), default=0) / len(result_set)

        objectives = [
            Objective("relevance", 0.40, mean(item["relevance"] for item in result_set)),
            Objective("diversity", 0.30, category_coverage),
            Objective("freshness", 0.15,
                      self.normalize_age(mean(item["age_hours"] for item in result_set))),
            Objective("quality", 0.10, mean(item["quality"] for item in result_set)),
            Objective("creator_diversity", 0.05, 1.0 - author_concentration),
        ]

        return {
            "category_coverage": category_coverage,
            "author_concentration": author_concentration,
            "objectives": {o.name: o.value for o in objectives},
            "composite": self.composite_score(objectives),
        }

权重怎么定:最可靠的做法是用历史数据反推。取一批线上真实的结果集,标注其中「用户满意度高」的比例,然后拟合出各目标的权重。权重确定之后,再用 A/B 实验验证。

如果暂时没有标注数据,可以用下面这套起步值,再逐步调整:

目标初始权重理由
相关性0.40相关性是推荐系统的基本盘,权重最高但不应过半
多样性0.30探索价值重要,但过重会伤点击率
时效性0.15对热榜类场景很重要,对长尾推荐可以更低
质量0.10质量信号本身滞后,适合用小权重配合护栏
创作者多样性0.05属于生态目标,可以直接用硬约束而非权重

什么时候不该用加权合成:当各个目标之间存在明显的不可兼得关系、且业务上无法给出相对偏好时,加权合成会掩盖冲突。这种情况下,帕累托前沿更合适——把「相关性最高」「多样性最高」等方案作为一组候选交给业务方选择,而不是强行压成一个数。

综合评估的落地位置:它更适合用在离线评估和策略对比上,而不是在线打分。在线排序仍然是按单一分数排的,多样性通过重排层实现。综合评估的作用是回答「这次策略调整之后,整体是变好了还是变差了」,为参数调整提供依据。

A/B 测试指标

  • 用户侧:停留时长、点击率、留存率、满意度
  • 内容侧:长尾内容曝光、新创作者冷启动成功率
  • 商业侧:广告填充率、转化率、eCPM

最佳实践

1. 渐进式多样性

用户生命周期策略:
新用户 → 高多样性(探索兴趣)
活跃用户 → 中多样性(平衡探索与利用)
成熟用户 → 动态调整(根据行为反馈)
流失风险 → 高多样性(重新激发兴趣)

2. 场景化策略

场景多样性权重说明
首页推荐中平衡用户体验
搜索发现低以相关性为主
探索频道高鼓励内容探索
关注流低用户主动选择
冷启动高快速建立画像

3. 实时监控

多样性是结果集层面的属性,无法从单条内容上判断,因此监控方式与单条内容的指标完全不同:要么在结果返回时顺带统计,要么对线上流量做抽样。

推荐做法是「在线轻量统计 + 离线精确统计」两层结合:

  • 在线轻量统计。结果返回时,顺便计算这一批内容的类别数、作者数和最大重复次数。这些统计是 O(n) 的,成本很低,可以直接随响应一起上报。它能提供实时的分布轮廓,但只反映单次请求,不反映长期趋势。
  • 离线精确统计。把线上请求的候选池与最终结果落库,批量计算熵值、基尼系数这类需要全局信息的指标。这类指标无法在单次请求内准确计算,只能离线做。
from collections import Counter
from dataclasses import dataclass


@dataclass
class DiversitySnapshot:
    """一次请求返回结果的多样性快照。"""
    request_id: str
    user_id: str
    result_count: int
    category_count: int
    author_count: int
    max_category_repeat: int
    max_author_repeat: int


class DiversityMonitor:
    """在线多样性轻量监控。"""

    def __init__(self, max_repeat_alert: int = 3, min_category_ratio: float = 0.3):
        self.max_repeat_alert = max_repeat_alert
        self.min_category_ratio = min_category_ratio

    def snapshot(self, request_id: str, user_id: str, result_set: list) -> DiversitySnapshot:
        categories = [item["category"] for item in result_set]
        authors = [item["author"] for item in result_set]

        category_counts = Counter(categories)
        author_counts = Counter(authors)

        return DiversitySnapshot(
            request_id=request_id,
            user_id=user_id,
            result_count=len(result_set),
            category_count=len(category_counts),
            author_count=len(author_counts),
            max_category_repeat=max(category_counts.values(), default=0),
            max_author_repeat=max(author_counts.values(), default=0),
        )

    def should_alert(self, snapshot: DiversitySnapshot) -> bool:
        """判断这次结果是否触发了多样性告警条件。"""
        if snapshot.result_count == 0:
            return False
        # 同一类别反复出现,说明多样性约束可能失效
        if snapshot.max_category_repeat >= self.max_repeat_alert:
            return True
        # 类别数量过少,说明结果过于同质
        if snapshot.category_count / snapshot.result_count < self.min_category_ratio:
            return True
        return False

监控指标与告警:

指标定义告警条件可能原因
平均类别数单次结果中的类别数均值低于下界多样性约束未生效或候选池单一
最大类别重复次数单次结果中同类内容出现的最大次数超过阈值滑动窗口参数失效
最大作者重复次数同上,按作者统计超过阈值作者配额缺失
类别覆盖率出现的类别数 / 候选池类别数持续下降候选池本身变窄
头部作者曝光占比曝光最多的作者占比持续上升创作者多样性约束缺失
离线熵值结果集类别分布的熵环比下降整体同质化趋势

告警要基于趋势而非绝对值。单次结果的类别数少可能只是因为候选池本来就窄,这不一定有问题。真正需要关注的是在相同候选池规模下,多样性指标是否在下降。因此监控时要把「候选池的类别数」作为对照一起上报,否则无法区分是算法退化了还是流量结构变了。

排查思路。多样性指标异常时,按下面的顺序定位:

  1. 先看候选池。候选池的类别分布是否已经变窄?如果是,问题出在召回或热度计算,不在多样性重排层。
  2. 再看重排是否执行。确认重排层没有被跳过(降级、缓存命中未重排都可能跳过这一步)。
  3. 再看参数。最近是否有配额、窗口大小、阈值的变更?变更记录要与指标异常的时间点对齐。
  4. 最后看算法。前面都正常时,才考虑聚类结果本身是否失真——比如语义模型更新后,簇的划分变得过于集中。

一个容易被忽略的监控点:多样性约束生效时,内容供给量会下降。如果只监控多样性指标而不监控供给量,很容易出现「多样性提升了,但用户看到的有效内容变少了」这种情况,而后者对留存的影响往往更大。两个指标必须一起看。

常见问题

Q1: 多样性导致点击率下降怎么办?

解决方案:

  1. 采用长期价值指标(留存、时长)
  2. 渐进式调整,避免剧烈变化
  3. 细分用户群体,个性化权重

Q2: 如何平衡头部与长尾内容?

曝光分配:头部 40-50%、腰部 30-40%、长尾 10-20%

Q3: 计算开销大如何优化?

解决方案:

  1. 预计算相似度矩阵,缓存复用
  2. 采用近似算法(如 LSH)
  3. 分阶段处理:粗排 + 精排
  4. 异步计算,流式处理

案例分析

案例 1:资讯平台多样性改造

背景:内容同质化严重

措施:引入 MMR,类别约束≤30%,增加创作者多样性

结果:7 日留存 +12%,消费类别数 3.2→5.1

案例 2:短视频冷启动

背景:新用户难建立兴趣画像

措施:前 20 条强制高多样性

结果:次日留存 +18%,画像建立时间 -40%

总结

  1. 明确目标:根据业务阶段确定优先级
  2. 选择算法:权衡效果与性能
  3. 持续优化:数据驱动迭代
  4. 全局视角:平衡体验、生态和商业

相关文档:01-概述 | 02-热度计算

发现内容有问题?

告诉我们哪里需要改进。