混合排序策略

概述

混合排序(Hybrid Sorting)是热门内容系统中的核心排序机制,它通过融合多种排序信号和策略,在保证内容质量的同时最大化用户参与度和平台生态健康。

为什么需要混合排序

单一排序的局限性

传统的单一排序策略存在明显缺陷:

排序方式优点缺点
纯热度排序简单直观,反映大众偏好马太效应严重,新内容难曝光
纯时间排序保证内容新鲜度质量参差不齐,用户体验差
纯个性化排序用户粘性高信息茧房,内容多样性低
纯质量排序内容品质高更新慢,时效性差

混合排序的价值主张

混合排序通过加权融合多种信号,实现以下目标:

  1. 质量保障:确保推荐内容的基本品质
  2. 时效平衡:兼顾热点内容与长尾内容
  3. 多样性:避免信息茧房,拓展用户视野
  4. 公平性:给予新内容和中小创作者曝光机会
  5. 商业化:合理融入广告和运营内容

核心架构设计

信号分层模型

┌─────────────────────────────────────────────────────────┐
│                    最终排序分数                          │
│              Final Ranking Score                        │
└─────────────────────────────────────────────────────────┘
                            ▲
                            │
        ┌───────────────────┼───────────────────┐
        │                   │                   │
┌───────▼───────┐  ┌────────▼────────┐  ┌──────▼───────┐
│   基础热度分   │  │   个性化调整分   │  │   业务规则分   │
│  Base Score   │  │ Personalization │  │ Business Rule│
└───────┬───────┘  └────────┬────────┘  └──────┬───────┘
        │                   │                   │
   ┌────┴────┐         ┌────┴────┐         ┌────┴────┐
   │ 点赞    │         │ 用户画像 │         │ 运营加权 │
   │ 评论    │         │ 兴趣标签 │         │ 广告插入 │
   │ 分享    │         │ 行为历史 │         │ 内容审核 │
   │ 播放    │         │ 位置信息 │         │ 合规过滤 │
   └─────────┘         └─────────┘         └─────────┘

评分公式

基础评分公式如下:

FinalScore = α × BaseScore + β × PersonalScore + γ × BusinessScore + δ × DiversityBonus

其中:
- α + β + γ + δ = 1.0
- 默认权重:α=0.5, β=0.3, γ=0.1, δ=0.1

基础热度分计算

多指标融合

基础热度分由多个互动指标加权计算:

基础热度分的构造分两步:先归一化,再加权。两步的顺序不能颠倒——浏览量的绝对值通常是分享量的百倍量级,直接加权会让浏览量一家独大,归一化正是为了消除这种量级差异。

各指标的权重与依据:

指标权重归一化方式选取依据
点赞0.20对数压缩操作成本低,反映轻度的内容认可
评论0.25对数压缩需要投入文字,参与深度高于点赞
分享0.40对数压缩操作成本最高,直接带来新流量
播放0.15对数压缩采样成本最低,最容易灌刷

四者的权重关系是分享最高、评论次之、点赞再次、播放最低,权重之和为 1,不同业务线的分数因此可以横向比较。

from dataclasses import dataclass
from math import log1p


@dataclass(frozen=True)
class BaseScoreWeights:
    """基础热度分的指标权重,四项之和必须为 1。"""

    like: float = 0.20
    comment: float = 0.25
    share: float = 0.40
    play: float = 0.15

    def validate(self) -> None:
        total = self.like + self.comment + self.share + self.play
        if abs(total - 1.0) > 1e-6:
            raise ValueError(f"权重之和必须为 1,当前为 {total}")


def normalize(value: int) -> float:
    """对数压缩:把长尾的原始计数压到同量级,同时保留大小关系。

    取 log(1 + v) 而不是 v / max,是为了避免「最高值」依赖单次采样,
    也让新内容即使只有个位数互动,也能拿到非零的分数。
    """
    if value <= 0:
        return 0.0
    return log1p(value)


def base_score(counts: dict, weights: BaseScoreWeights = BaseScoreWeights()) -> float:
    """计算基础热度分。

    counts 的键为 like / comment / share / play。
    """
    weights.validate()
    return sum(
        weight * normalize(counts.get(dimension, 0))
        for dimension, weight in (
            ("like", weights.like),
            ("comment", weights.comment),
            ("share", weights.share),
            ("play", weights.play),
        )
    )

为什么要按行为成本分配权重:行为成本越高,说明用户投入越大,权重应该越高。分享要经过一次跨平台跳转,评论要打字,点赞只要一次点击。这个顺序不能因为「点赞量好看」而颠倒过来——否则点赞会被刷,权重又高,榜单直接失守。

归一化方式的选择:

方式公式优点缺点
线性归一化v / max直观依赖单次采样,新内容几乎得 0 分
对数压缩log(1 + v)保留大小关系,新内容也有分高分段区分度下降
Z-Score(v - μ) / σ分布更均衡需要窗口统计量,冷启动困难
分位数按历史分位映射抗异常值需要离线分位数表

推荐对数压缩:它不依赖任何全局统计量,在线就能算,而且新内容不会因为「还没积累到最大值」而直接归零。

指标权重动态调整

权重不是一成不变的,需要根据业务阶段动态调整:

业务阶段点赞权重评论权重分享权重播放权重
冷启动期30%30%25%15%
成长期35%25%20%20%
成熟期35%25%20%20%
变现期30%20%15%35%

时间衰减机制

指数衰减模型

内容热度随时间自然衰减,采用指数衰减模型:

TimeDecay = e^(-λ × Δt)

其中:
- λ: 衰减速率系数(通常 0.1-0.5)
- Δt: 内容发布后经过的时间(小时)

分段衰减策略

不同内容类型采用不同衰减速率:

一刀切的衰减系数会让所有内容以同样的速度变冷,但内容的生命周期差异极大——一条突发新闻的生命周期以小时计,一篇技术教程的生命周期以周计。用同一组参数,必然出现「新闻还没热起来就凉了」或者「教程三个月还挂在榜上」。

按内容类型分档的配置:

内容类型衰减系数 λ\lambda等价半衰期调整依据
突发新闻0.35约 2 小时时效性极强,用户注意力几分钟内就会转移
常规资讯0.12约 6 小时覆盖一个上午到傍晚的传播周期
短视频0.08约 9 小时借助推荐分发持续获得长尾流量
深度长文0.02约 35 小时讨论热度会持续发酵,不宜过早下沉
知识教程0.005约 6 天长尾内容靠搜索和收藏持续贡献价值

换算关系是 λ=ln⁡(2)/H\lambda = \ln(2) / H,其中 HH 是半衰期。业务同学能直接理解「多久热度减半」,比「衰减系数 0.35」友好得多。

from math import exp, log

# 各内容类型的半衰期(小时),配置下发后可热更新
HALF_LIFE_HOURS = {
    "breaking_news": 2.0,
    "news": 6.0,
    "video": 9.0,
    "article": 35.0,
    "tutorial": 144.0,
}


def decay_factor(content_type: str, hours_since_publish: float) -> float:
    """按内容类型计算时间衰减因子。

    未配置的内容类型回退到 6 小时半衰期,
    与「常规资讯」一档,避免出现未知的冷门类型衰减异常。
    """
    half_life = HALF_LIFE_HOURS.get(content_type, 6.0)
    if hours_since_publish <= 0:
        return 1.0
    return pow(0.5, hours_since_publish / half_life)


def lambda_of(content_type: str) -> float:
    """返回该内容类型对应的等价衰减系数。"""
    half_life = HALF_LIFE_HOURS.get(content_type, 6.0)
    return log(2) / half_life

分段的另一种做法是「分段用不同系数」,而不是「每类一个系数」。内容发布后的热度变化并不是匀速的:刚发布时应该快速上榜以抓住时机,过了峰值之后衰减可以放缓,让优质内容有更长的时间被看到。

阶段时间范围衰减处理理由
爆发期0 到 2 小时快速上升或保持高位抓住事件热度窗口
峰值期2 到 12 小时标准指数衰减正常传播周期
长尾期12 小时以后衰减系数减半优质内容不应被过早淘汰
def staged_decay_factor(content_type: str, hours_since_publish: float) -> float:
    """分段衰减:长尾期的衰减速率放慢。

    做法是在标准衰减的基础上,对超过 12 小时的内容
    按更小的系数重新计算一次,避免长尾内容被一刀切掉。
    """
    if hours_since_publish <= 0:
        return 1.0

    half_life = HALF_LIFE_HOURS.get(content_type, 6.0)
    base = pow(0.5, hours_since_publish / half_life)

    if hours_since_publish <= 12:
        return base

    # 长尾段:用双倍半衰期重新计算,让衰减变缓
    tail_start = pow(0.5, 12 / half_life)
    tail = pow(0.5, (hours_since_publish - 12) / (half_life * 2))
    return tail_start * tail

两个容易踩的坑:

  • 单位必须统一。有的系统按秒计时,有的按小时。如果半衰期配的是小时、而传入的时间是秒,衰减会快 3600 倍。变量名里写清单位(hours_since_publish)比靠约定可靠。
  • 参数要能热更新。内容类型的划分和衰减参数都属于业务参数,应该放在配置中心。发版才能改的参数,在发现「教程类内容掉榜太快」这种问题时,响应速度太慢了。

个性化调整分

用户兴趣匹配

基于用户历史行为计算兴趣匹配度:

PersonalScore = Σ(InterestWeight_i × ContentTag_i × TagAffinity_i)

其中:
- InterestWeight_i: 用户对各兴趣类别的权重
- ContentTag_i: 内容标签的权重
- TagAffinity_i: 用户对该标签的亲和度(0-1)

协同过滤增强

引入协同过滤信号提升排序质量:

协同过滤的思路是:喜欢同样内容的用户,往往还喜欢别的相似内容。它不需要理解内容本身,只需要用户与内容的交互记录,因此可以作为个性化信号的一个独立来源,和标签匹配互相补充。

在信息流场景里,最常用的是基于物品的协同过滤——用内容之间的共现关系来计算相似度,而不是用用户之间的相似度。原因是用户的行为稀疏,而内容之间的共现关系在热门内容上非常密集。

基于物品的协同过滤的核心是共现矩阵:

用户对内容的交互矩阵(行是用户,列是内容,1 表示有互动)

        内容A  内容B  内容C  内容D
用户1    1     0     1     0
用户2    1     1     0     0
用户3    0     1     1     0

内容A 与 内容C 的共现用户数 = 2(用户1、用户3)
内容A 与 内容B 的共现用户数 = 1(用户2)
from collections import defaultdict
from math import log, sqrt


def cosine_similarity(vector_a: dict, vector_b: dict) -> float:
    """计算两个稀疏向量的余弦相似度。

    vector 的键是内容 ID,值是交互强度。
    用对数压缩交互强度,避免重度用户的单条内容主导相似度。
    """
    if not vector_a or not vector_b:
        return 0.0

    common = set(vector_a.keys()) & set(vector_b.keys())
    if not common:
        return 0.0

    numerator = sum(
        log1p(vector_a[key]) * log1p(vector_b[key]) for key in common
    )
    norm_a = sqrt(sum(log1p(v) ** 2 for v in vector_a.values()))
    norm_b = sqrt(sum(log1p(v) ** 2 for v in vector_b.values()))
    if norm_a == 0 or norm_b == 0:
        return 0.0

    return numerator / (norm_a * norm_b)


class ItemCF:
    """基于物品的协同过滤。

    两步:
    1. 离线从交互日志里算出内容之间的相似度矩阵;
    2. 在线用用户的历史交互内容,检索相似内容作为候选。
    """

    def __init__(self, top_k: int = 50):
        self.top_k = top_k
        # 相似度矩阵:内容 ID -> [(相似内容 ID, 相似度), ...]
        self.similarities = defaultdict(list)

    def fit(self, interactions: list) -> None:
        """离线计算相似度矩阵。

        interactions 中每个元素是 (user_id, content_id, strength),
        strength 是交互强度,例如点赞为 3、完播为 1。
        """
        # 用户 -> 内容 -> 交互强度
        user_items = defaultdict(dict)
        for user_id, content_id, strength in interactions:
            user_items[user_id][content_id] = strength

        # 内容 -> 用户 -> 交互强度
        item_users = defaultdict(dict)
        for user_id, items in user_items.items():
            for content_id, strength in items.items():
                item_users[content_id][user_id] = strength

        content_ids = list(item_users.keys())
        for i, content_a in enumerate(content_ids):
            vector_a = {
                item: strength
                for item, strength in item_users[content_a].items()
            }
            candidates = []
            for content_b in content_ids[i + 1:]:
                vector_b = item_users[content_b]
                similarity = cosine_similarity(vector_a, vector_b)
                if similarity > 0:
                    candidates.append((content_b, similarity))
            candidates.sort(key=lambda pair: pair[1], reverse=True)
            self.similarities[content_a] = candidates[:self.top_k]

    def recommend(self, user_items: dict, candidate_ids: list) -> list:
        """在线推荐:用用户历史交互过的内容召回相似内容。

        user_items 是用户历史交互的内容及其强度,
        candidate_ids 是本次的候选内容集合。
        """
        scores = defaultdict(float)
        for history_id, history_strength in user_items.items():
            for similar_id, similarity in self.similarities.get(history_id, []):
                if similar_id in candidate_ids:
                    scores[similar_id] += similarity * log1p(history_strength)

        ranked = sorted(scores.items(), key=lambda pair: pair[1], reverse=True)
        return [content_id for content_id, _ in ranked]

协同过滤信号如何进入最终分数:

PersonalScore = Σ(协同过滤得分 × 权重) + Σ(标签匹配得分 × 权重)
信号权重建议特点
协同过滤得分0.3基于共同消费行为,覆盖标签体系外的兴趣
标签匹配得分0.5可解释性强,便于运营理解
兴趣序列得分0.2反映短期意图,衰减快

协同过滤的三个固有限制:

  • 冷启动困难。新内容没有交互记录,相似度算不出来,只能靠标签匹配和运营加权来兜底。这也是为什么冷启动机制必须独立存在。
  • 马太效应。基于共现的相似度天然偏向热门内容——热门内容和更多内容共现,因此和更多内容相似。这会让长尾内容更难被推荐出去。
  • 数据稀疏。低活跃用户的交互记录很少,算出来的相似度噪声很大。

实践中的应对:

问题应对手段
冷启动新内容走标签匹配 + 运营加权,积累到一定交互量后再进协同过滤
马太效应对热门内容的相似度贡献做惩罚,例如除以该内容的流行度
数据稀疏用时间衰减给近期交互更高权重,只看最近 30 天的行为

流行度惩罚是最有效的一个缓解手段,公式是把相似度除以内容的流行度(交互用户数的对数):

def penalized_similarity(similarity: float, popularity: float) -> float:
    """流行度惩罚:相似度除以流行度的对数。

    热门内容的流行度高,惩罚因子小,
    于是它不再天然地与所有内容都相似。
    """
    if popularity <= 1:
        return similarity
    return similarity / log(popularity)

实时行为反馈

用户实时行为即时影响排序:

行为类型影响因子持续时间
完整播放+0.15本次会话
点赞+0.1024 小时
评论+0.1224 小时
分享+0.2048 小时
跳过-0.05本次会话
举报-0.50永久

多样性保障

类别多样性

避免同一类别内容过度集中:

热门内容天然会向头部集中——排在最前面的内容互动多,互动多又让它排得更前。如果不加以干预,用户的信息流会被同一个类别占满。多样性机制的作用是在分数接近时,用结构约束改变顺序。

最常用的是最大边际相关性(MMR)。它在做贪心选择时同时考虑两个目标:内容本身的相关性,以及它与已选内容集合的差异度。

MMR=λ⋅Rel(c)−(1−λ)⋅max⁡s∈SSim(c,s)\text{MMR} = \lambda \cdot \text{Rel}(c) - (1 - \lambda) \cdot \max_{s \in S} \text{Sim}(c, s)

其中 SS 是已选内容的集合,λ\lambda 是相关性权重。λ\lambda 接近 1 时偏向相关性,接近 0 时偏向多样性。

def mmr_rerank(candidates: list, relevance_key: str, similarity_fn, lambda_relevance: float = 0.7,
                top_n: int = 20) -> list:
    """最大边际相关性重排。

    candidates 中每个元素需包含 score 字段,
    similarity_fn(a, b) 返回两条内容之间的相似度,取值 0 到 1。
    """
    selected = []
    remaining = list(candidates)

    while remaining and len(selected) < top_n:
        best_item = None
        best_value = None

        for item in remaining:
            relevance = item.get(relevance_key, 0.0)
            if selected:
                # 与已选内容中相似度最高的那一条比较,这是 MMR 的关键
                max_similarity = max(similarity_fn(item, chosen) for chosen in selected)
            else:
                max_similarity = 0.0

            value = lambda_relevance * relevance - (1 - lambda_relevance) * max_similarity
            if best_value is None or value > best_value:
                best_value = value
                best_item = item

        selected.append(best_item)
        remaining.remove(best_item)

    return selected

类别维度的多样性还有一种更简单的实现:滑窗配额。在最终输出的 20 条里,限制同一个类别最多出现若干条。

策略做法优点缺点
MMR 重排贪心选择时兼顾差异度效果最好,内容相似度通用计算复杂度高,需要相似度矩阵
滑窗配额每 N 条里同类别不超过 M 条实现简单,开销极低边界处可能集中
类目封顶整个列表中同类别不超过 K 条约束最强供给不足时无法填满
打散重排同类别内容按分数间隔插入实现最简单不改变内容集合,效果有限

滑窗配额的实现最直接:

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 滑窗配额重排:保证任意连续 windowSize 条内容中,
 * 同一类别最多出现 maxPerCategory 条。
 */
public class CategoryQuotaReranker {

    private final int windowSize;
    private final int maxPerCategory;

    public CategoryQuotaReranker(int windowSize, int maxPerCategory) {
        this.windowSize = windowSize;
        this.maxPerCategory = maxPerCategory;
    }

    /**
     * 重排候选内容。
     *
     * 做法是双层遍历:先按分数从高到低选,
     * 每选一条就检查它是否会挤掉窗口内同类别已达上限的内容。
     */
    public List<RankItem> rerank(List<RankItem> candidates) {
        List<RankItem> selected = new ArrayList<>();
        Map<String, Integer> recentCounts = new HashMap<>();

        for (RankItem item : candidates) {
            if (selected.size() >= candidates.size()) {
                break;
            }

            String category = item.category();
            int count = recentCounts.getOrDefault(category, 0);
            if (count < maxPerCategory) {
                selected.add(item);
                recentCounts.put(category, count + 1);

                // 窗口前移,移除不再属于窗口的元素的计数
                if (selected.size() > windowSize) {
                    RankItem expired = selected.get(selected.size() - windowSize - 1);
                    String expiredCategory = expired.category();
                    int remaining = recentCounts.get(expiredCategory) - 1;
                    if (remaining <= 0) {
                        recentCounts.remove(expiredCategory);
                    } else {
                        recentCounts.put(expiredCategory, remaining);
                    }
                }
            }
        }

        // 配额约束下没能选上的内容,按原顺序追加到末尾
        for (RankItem item : candidates) {
            if (!selected.contains(item)) {
                selected.add(item);
            }
        }
        return selected;
    }
}

尾部追加这一步不能省。当候选内容的类别分布本身就很集中时,严格执行配额会导致列表填不满——最终展示 12 条而不是 20 条。尾部追加保证了列表长度不变,同时在末尾用分数较低的内容补齐,用户几乎感知不到。

参数怎么定:

参数取值影响
窗口大小10用户通常一次滑动看 10 条左右,约束窗口与视口对齐最自然
单类别上限3上限为 3 时,10 条里最多 3 条同类别,其余由其他类别填充

多维度的多样性要同时考虑类别、作者和话题。做法是把它们合成一个类别键:

// 多样性分组键:把类别、作者、话题拼在一起
String diversityKey = item.category() + "|" + item.authorId() + "|" + item.topic();

这样同类别、同作者、同话题的内容都会被纳入同一个配额组,效果比单一维度更强,但阈值也要相应放宽。

创作者多样性

限制单一创作者内容占比:

MaxCreatorRatio = 0.15  # 单个创作者最多占 15%

如果超过阈值,后续内容降权系数 = 0.5

新颖性探索

引入探索机制发现潜在优质内容:

排序系统的目标函数天然倾向于「推荐已经表现好的内容」——它有明确的反馈信号,计算成本低,风险也低。代价是优质的新内容永远拿不到第一次机会。探索机制就是专门为解决这件事存在的。

探索与利用的矛盾:

策略做法收益代价
纯利用(贪心)永远选当前分数最高的短期指标最优新内容永远沉底,生态僵化
纯随机完全随机推荐新内容有机会用户体验差,指标崩塌
ϵ\epsilon-greedy以 ϵ\epsilon 的概率随机选简单,可控浪费的流量与 ϵ\epsilon 成正比
UCB按「收益 + 探索价值」选择探索效率高需要维护每个内容的尝试次数
Thompson 采样按后验分布采样天然处理不确定性实现复杂,需要建模

ϵ\epsilon-greedy 是最简单也最常用的。它的做法是:以 ϵ\epsilon 的概率从候选里随机选一个,否则选分数最高的。

import random


def epsilon_greedy(candidates: list, epsilon: float = 0.1, top_n: int = 20) -> list:
    """epsilon-greedy 选择。

    以 epsilon 的概率从候选中随机取,其余按分数从高到低取。
    epsilon 应当随系统成熟度递减:探索的价值会随时间下降。
    """
    if not candidates:
        return []

    selected = []
    pool = list(candidates)

    while pool and len(selected) < top_n:
        if random.random() < epsilon:
            # 探索:从剩余候选里随机取一条
            index = random.randrange(len(pool))
        else:
            # 利用:取分数最高的一条
            index = max(range(len(pool)), key=lambda i: pool[i].get("score", 0.0))
        selected.append(pool.pop(index))

    return selected

把随机探索换成「带惩罚的探索」效果更好。惩罚项给新内容一个临时的分数加成,让它有机会进入靠前的位置,而不是等它随机被抽中:

def exploration_bonus(content_id: str, exposure_count: int, bonus_cap: float = 0.3) -> float:
    """探索加成:曝光越少,加成越高。

    加成随曝光次数递减,封顶在 bonus_cap,
    避免探索加成压过内容本身的分数。
    """
    if exposure_count <= 0:
        return bonus_cap
    return bonus_cap / (1 + exposure_count)

这样新内容在还没有曝光记录时能获得最高加成,一旦有了曝光就逐步回落。这本质上是一个 UCB 的简化版:曝光次数就是「不确定性」的代理。

探索池机制是把探索落到工程上的常见做法:

探索池:
- 流量占比:总流量的 5%
- 准入条件:新发布且未在主流量池出现过
- 曝光测试:累计 1000 次曝光
- 通过标准:互动率 > 3%
- 通过后:进入主流量池参与正常排序
- 未通过:降低推荐权重,但不立即下线

探索流量的分配:

阶段探索流量占比理由
系统上线初期10%缺乏历史数据,需要大量探索积累信号
稳定运营期5%平衡探索与利用
内容供给过剩时8%给长尾内容更多机会,缓解同质化
大促或热点期2%热点期用户要的是确定性,探索会干扰体验

探索的三个纪律:

  1. 探索必须打标。被探索推荐的内容要带标记,否则统计「点击率」时会把探索流量和正常流量混在一起,算出来的效果没有可比性。
  2. 探索成本要能算清。探索流量的占比虽然小,但它是确定性的收益损失。要明确它换来了什么——比如长尾内容的曝光占比提升了多少、新内容从零到一千曝光的中位时间缩短了多少。
  3. 探索要有终止条件。一个内容在探索池里待了太久还没通过,说明它确实不行,要把它移出去。探索池不能只进不出。

业务规则干预

运营加权

运营人工干预的优先级最高:

运营干预是这套系统里优先级最高但也最需要约束的一路信号。它的优先级高,是因为一条经过审核确认的置顶或加权,背后的业务意图是明确且必须兑现的。但正因为如此,它也最容易变成一个「谁声音大谁说了算」的黑洞,最终让热榜失去公信力。

常见的运营干预类型:

类型作用生效范围典型时长
置顶固定出现在指定位置指定位置1 到 7 天
加权给热度分乘一个系数全量榜单1 到 3 天
降权给热度分乘一个小于 1 的系数全量榜单1 到 3 天
屏蔽从候选集中直接剔除全量榜单直到解除
分类推荐固定出现在某个频道首位指定频道1 到 7 天
标签加权某个标签下的内容整体加权标签维度1 到 3 天

实现上,运营干预不应该直接改热度分,而应该作为一路独立的信号进入排序:

最终分数 = α × 基础热度分 + β × 个性化调整分 + γ × 业务规则分 + δ × 多样性奖励

业务规则分里包含运营加权:

import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 运营干预管理器。
 *
 * 干预记录存在 Redis 里,排序服务按内容 ID 读取。
 * 每条记录都带有效期和操作人,过期自动失效。
 */
public class OperationOverrideManager {

    /** 加权记录的 key 前缀。 */
    private static final String WEIGHT_KEY_PREFIX = "op:weight:";

    /** 屏蔽记录的 key 前缀。 */
    private static final String BLOCK_KEY_PREFIX = "op:block:";

    /** 置顶记录的 key 前缀。 */
    private static final String PIN_KEY_PREFIX = "op:pin:";

    private final JedisPool jedisPool;

    public OperationOverrideManager(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
    }

    /**
     * 运营加权。
     *
     * @param contentId 内容 ID
     * @param factor    加权系数,大于 1 表示加权,小于 1 表示降权
     * @param operator  操作人,必须可追溯
     * @param reason    干预原因,必须填写
     * @param validSeconds 生效时长
     */
    public void setWeight(String contentId, double factor, String operator, String reason,
                          long validSeconds) {
        if (factor <= 0) {
            throw new IllegalArgumentException("加权系数必须大于 0");
        }
        if (reason == null || reason.isBlank()) {
            // 没有原因的干预,事后无法解释,也无法评估效果
            throw new IllegalArgumentException("必须填写干预原因");
        }

        String key = WEIGHT_KEY_PREFIX + contentId;
        try (Jedis jedis = jedisPool.getResource()) {
            jedis.hset(key, Map.of(
                    "factor", String.valueOf(factor),
                    "operator", operator,
                    "reason", reason,
                    "created_at", Instant.now().toString()));
            jedis.expire(key, validSeconds);
        }
    }

    /**
     * 读取内容当前的加权系数。没有干预时返回 1.0。
     */
    public double weightOf(String contentId) {
        try (Jedis jedis = jedisPool.getResource()) {
            String factor = jedis.hget(WEIGHT_KEY_PREFIX + contentId, "factor");
            if (factor == null) {
                return 1.0;
            }
            try {
                return Double.parseDouble(factor);
            } catch (NumberFormatException e) {
                // 配置被写坏时退回中性值,不要因为一条脏数据让整个榜单失效
                return 1.0;
            }
        }
    }

    /**
     * 屏蔽内容。
     */
    public void block(String contentId, String operator, String reason, long validSeconds) {
        String key = BLOCK_KEY_PREFIX + contentId;
        try (Jedis jedis = jedisPool.getResource()) {
            jedis.hset(key, Map.of(
                    "operator", operator,
                    "reason", reason,
                    "created_at", Instant.now().toString()));
            jedis.expire(key, validSeconds);
        }
    }

    /**
     * 内容是否被屏蔽。
     */
    public boolean isBlocked(String contentId) {
        try (Jedis jedis = jedisPool.getResource()) {
            return jedis.exists(BLOCK_KEY_PREFIX + contentId);
        }
    }
}

运营干预的四条纪律:

  1. 干预必须有时效。每一条干预都要设过期时间。没有时效的干预会变成事实上的永久状态,运营自己也记不清当时为什么加的权重。默认给一个保守的时长,到期后需要重新申请。
  2. 干预必须有原因和责任人。原因是给审核和用户看的,责任人是对效果负责的。没有这两项,事后复盘时既说不清为什么改,也找不到该去问谁。
  3. 干预量要有上限。同时生效的干预条数要设阈值并告警。一条内容被多方反复加权、叠加后权重能翻好几倍,热榜的排序就失去了意义。
  4. 干预要可回滚。所有干预记录进操作日志,支持按内容 ID 和操作人批量回滚。发一次错、影响面太大时,能在分钟级撤销。

监控上要盯的指标:

指标说明关注点
生效干预条数当前有效的干预记录数持续上升说明干预被当成了常规手段
干预影响的内容曝光占比被干预内容占据的曝光比例超过 20% 说明榜单公信力受损
干预内容的自然排名撤掉干预后内容会排在第几位差距过大说明干预在掩盖真实热度
干预平均存活时长干预从创建到失效的平均时长长期不失效的干预要复审

最后一条指标最关键。「撤掉干预后内容会排在第几位」能直接暴露干预的合理性——如果一条内容去掉运营加权后还在第一位,说明干预本来就没必要;如果去掉后掉到五十名开外,那这条干预实际上是在替代排序系统工作,这是需要警惕的信号。

广告插入策略

广告内容按策略插入信息流:

位置广告密度排序方式
第 3 位固定按 eCPM 排序
第 8 位固定按 eCPM 排序
第 15 位+动态按 eCPM× 相关性

合规过滤

违规内容直接过滤:

合规过滤和前面几路信号有一个本质区别:它不是「加分」或「减分」,而是「有没有」的判断。违规内容不进入候选集,而不是排在最后一位。这个区别决定了它在链路上的位置——必须放在最前面。

过滤的执行顺序:

候选内容
   │
   ▼
┌──────────────────────────┐
│ L1 内容审核状态           │  查审核服务的结论,O(1)
└────────────┬─────────────┘
             │ 未通过
             ▼
┌──────────────────────────┐
│ L2 关键词与敏感词         │  查关键词黑名单,O(1)
└────────────┬─────────────┘
             │ 未命中
             ▼
┌──────────────────────────┐
│ L3 语义识别               │  文本模型,昂贵
└────────────┬─────────────┘
             │ 未识别
             ▼
          进入排序

三类过滤手段的对比:

手段覆盖范围准确率延迟漏过的后果
审核状态已被审核判定违规的内容最高最低依赖审核覆盖率
关键词匹配已知违禁词中低变体字、谐音字容易漏
语义识别隐含违规的表达中高模型误判会伤正常内容

审核状态是最可靠也最容易被绕过的一层。它的前提是内容真的过了审核,而新发布的内容、绕过审核的接口调用、编辑后未重新审核的内容,都不在这个状态的覆盖范围内。因此后面两层是对它的补充,不是替代。

import java.util.HashSet;
import java.util.Set;

/**
 * 合规过滤器。
 *
 * 三层判定,任一层判定违规即剔除,不进入后续排序。
 */
public class ComplianceFilter {

    /** 违禁词集合。 */
    private final Set<String> blockedKeywords;

    /** 审核状态查询接口。 */
    private final ModerationService moderationService;

    public ComplianceFilter(Set<String> blockedKeywords, ModerationService moderationService) {
        this.blockedKeywords = new HashSet<>(blockedKeywords);
        this.moderationService = moderationService;
    }

    /**
     * 过滤候选内容。
     *
     * @param candidates 候选内容
     * @return 通过合规检查的内容
     */
    public List<RankItem> filter(List<RankItem> candidates) {
        List<RankItem> passed = new ArrayList<>(candidates.size());

        for (RankItem item : candidates) {
            // L1:审核状态
            ModerationStatus status = moderationService.statusOf(item.contentId());
            if (status == ModerationStatus.REJECTED
                    || status == ModerationStatus.UNDER_REVIEW) {
                // 待审的内容也不放行:宁可少一条,不可漏一条
                continue;
            }

            // L2:关键词
            if (containsBlockedKeyword(item)) {
                continue;
            }

            passed.add(item);
        }

        return passed;
    }

    /**
     * 判断文本中是否含有违禁词。
     *
     * 做归一化后再匹配:去掉空白与常见分隔符,
     * 避免「违-禁-词」这类简单变形绕过。
     */
    private boolean containsBlockedKeyword(RankItem item) {
        String normalized = normalize(item.text());
        for (String keyword : blockedKeywords) {
            if (normalized.contains(normalize(keyword))) {
                return true;
            }
        }
        return false;
    }

    /**
     * 文本归一化:去掉空白字符和常见分隔符,转小写。
     */
    private String normalize(String text) {
        if (text == null) {
            return "";
        }
        return text.replaceAll("\\s+", "")
                .replace("-", "")
                .replace("_", "")
                .replace("*", "")
                .toLowerCase();
    }
}

过滤这一层最容易出问题的三个地方:

  • 不能因为过滤服务不可用就放行全部。审核服务挂掉时,正确做法是保守处理——要么走本地关键词兜底,要么对该批次内容延后发布。合规问题上的默认放行,风险远大于短暂的内容缺失。
  • 过滤和降权不能混用。违规内容是「不出现」,低质内容是「排在后面」。把违规内容降权处理,等于告诉用户「你可以点进去看看」,这是完全不同的后果。
  • 过滤要记日志并可追溯。被过滤的内容、命中的规则、命中的时间都要记录。误过滤的申诉要能查,监管问询也要能答。

监控指标:

指标说明关注点
各层过滤命中数L1、L2、L3 分别拦下多少某一层长期为 0 说明该层没生效
过滤总拦截率被过滤内容占候选的比例突然上升说明出现了批量违规或规则误伤
审核服务可用性状态查询的失败率不可用时必须触发保守策略
误过滤申诉数用户申诉中判定为误过滤的比例持续上升说明规则过严

冷启动处理

新内容扶持

新发布内容获得额外曝光:

BoostScore = BaseScore × (1 + NewContentBoost)

NewContentBoost = max(0, 0.5 - hours_since_publish / 24)

新创作者保护

新创作者内容获得流量倾斜:

创作者等级流量系数扶持期
Lv.0(新注册)1.5×7 天
Lv.1(首内容)1.3×14 天
Lv.2(10 内容)1.1×30 天
Lv.3+1.0×-

探索池机制

新内容进入探索池进行小流量测试:

探索池流量 = 总流量的 5%
测试样本 = 1000 次曝光
通过率阈值 = 互动率 > 3%

通过 → 进入主流量池
未通过 → 降低推荐权重

工程实现

排序服务架构

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│  候选内容   │ ──► │  粗排层     │ ──► │  精排层     │
│  Candidate  │     │  Rough Rank │     │  Fine Rank  │
│  Pool       │     │  (Top 500)  │     │  (Top 50)   │
└─────────────┘     └─────────────┘     └─────────────┘
                                              │
                                              ▼
                                      ┌─────────────┐
                                      │  重排层     │
                                      │  Re-Rank    │
                                      │  (Final 20) │
                                      └─────────────┘

性能优化策略

混合排序把多个信号叠加在一起,链路上的每一段都会贡献延迟。优化要按「先减少计算量,再减少等待,最后才做微优化」的顺序推进。

阶段优化手段做法收益
候选生成分层召回 + 截断多路召回各自取头部,合并后统一截断到固定规模直接决定后续所有阶段的计算量
特征获取预计算 + 批量拉取离线算好特征存 Redis,在线一次批量取回避免逐条回源
粗排轻量模型用简化特征和线性模型筛掉大部分候选把精排的候选规模降一个量级
精排特征裁剪 + 超时降级只取模型真正用到的特征;超时则回退到粗排结果保证 P99 可控
重排预计算相似度候选间的相似度矩阵提前算好并缓存避免在线做 O(n²) 的相似度计算
结果组装异步预渲染热门页面的结果提前序列化好减少序列化和网络开销

最有效的一条:把候选集规模控制住。 混合排序的性能开销几乎都随候选规模呈超线性增长。把候选集从几千条降到几百条,粗排、精排、重排三段的开销会同时下降。

import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

/**
 * 排序服务的性能优化实现。
 */
public class OptimizedRanker {

    /** 粗排保留的候选数量。 */
    private static final int ROUGH_KEEP = 500;

    /** 精排保留的候选数量。 */
    private static final int FINE_KEEP = 50;

    /** 最终返回的条数。 */
    private static final int FINAL_SIZE = 20;

    /** 精排的超时时间,超时后降级到粗排结果。 */
    private static final long FINE_RANK_TIMEOUT_MS = 30L;

    private final RecallService recallService;
    private final RoughRankService roughRankService;
    private final FineRankService fineRankService;
    private final ReRankService reRankService;

    public OptimizedRanker(
            RecallService recallService,
            RoughRankService roughRankService,
            FineRankService fineRankService,
            ReRankService reRankService) {
        this.recallService = recallService;
        this.roughRankService = roughRankService;
        this.fineRankService = fineRankService;
        this.reRankService = reRankService;
    }

    /**
     * 排序主流程。每一段都有明确的规模约束和降级路径。
     */
    public List<RankItem> rank(RankContext context) {
        // 阶段一:多路召回并行执行,避免串行累加延迟
        List<Candidate> candidates = recallService.recallParallel(context, ROUGH_KEEP);

        // 阶段二:粗排,用轻量特征快速筛出头部
        List<Candidate> rough = roughRankService.rank(candidates, ROUGH_KEEP);

        // 阶段三:精排,带超时降级
        List<Candidate> fine;
        try {
            fine = CompletableFuture.supplyAsync(
                            () -> fineRankService.rank(rough, FINE_KEEP))
                    .get(FINE_RANK_TIMEOUT_MS, TimeUnit.MILLISECONDS);
        } catch (Exception e) {
            // 精排超时或失败时降级到粗排结果,保证请求不失败
            fine = rough.size() > FINE_KEEP ? rough.subList(0, FINE_KEEP) : rough;
        }

        // 阶段四:重排,应用多样性、业务规则等约束
        return reRankService.reRank(fine, FINAL_SIZE);
    }
}

几条容易被忽略的优化点:

  • 并行化要从「串行依赖」中找机会。多路召回之间没有依赖,可以并行;但精排依赖粗排的结果,只能串行。把能并行的部分并行化,是延迟优化里性价比最高的一步。
  • 超时降级比无限等待好。精排超时时回退到粗排结果,用户看到的内容质量略降,但页面能用。如果不做降级,一个模型服务的抖动就会传导成整个信息流的不可用。
  • 缓存要区分「结果缓存」和「中间结果缓存」。热门用户的整页结果可以整体缓存,但这类缓存的失效逻辑要跟内容更新绑定,否则会出现「内容已下架但缓存还在返回」的问题。相比之下,特征缓存和相似度矩阵缓存的失效逻辑简单得多,收益也更稳定。
  • 序列化开销常常被低估。信息流接口返回几十条内容,如果每条都带完整的元数据,序列化和网络传输可能比排序本身还慢。生产环境通常只返回列表页需要的精简字段,详情由二次请求获取。

监控上要配合的指标:优化不能以牺牲效果为代价。建议同时监控排序各阶段的耗时分布和通过率——粗排到精排的存活率如果突然下降,说明粗排模型或特征出了问题,即使总延迟看起来正常。

实时计算流水线

用户请求 → 获取候选集 → 特征提取 → 模型预测 → 规则应用 → 返回结果
   │                                              │
   └───────────────── 50ms SLA ───────────────────┘

监控与调优

核心指标监控

指标目标值告警阈值
点击率 (CTR)> 5%< 3%
完播率> 40%< 25%
互动率> 8%< 5%
负反馈率< 1%> 3%
排序延迟 (P99)< 100ms> 200ms

A/B 测试框架

混合排序的所有权重(α\alpha、β\beta、γ\gamma、δ\delta)都是无法靠推理确定的参数,只能靠实验找到合适的取值。因此实验框架不是可选项,而是这套系统的必备组件。

框架的三个层次:

┌─────────────────────────────────────────────────────────┐
│  第 1 层:分流层                                         │
│  负责把用户稳定地分到不同的实验组                        │
└───────────────────────────┬─────────────────────────────┘
                            ▼
┌─────────────────────────────────────────────────────────┐
│  第 2 层:实验层                                         │
│  一个用户可以同时命中多个正交的实验                       │
└───────────────────────────┬─────────────────────────────┘
                            ▼
┌─────────────────────────────────────────────────────────┐
│  第 3 层:参数层                                         │
│  每个实验把参数写回排序配置,排序服务按用户 ID 取参数      │
└─────────────────────────────────────────────────────────┘

分流必须满足三个性质:

性质含义不满足的后果
确定性同一用户每次分流结果相同用户在不同分组间跳变,指标无法归因
均匀性各组流量占比符合预期实验组与对照组的用户结构不同,结论失真
互斥性互斥实验组之间不重叠同一用户同时受到两种策略影响,效果无法分离

正交性是关键设计。权重实验(调整 α\alpha、β\beta)和多样性实验(调整配额)应该正交,让同一个用户可以同时进入「权重实验 A 组」和「多样性实验 B 组」。这样能大幅提升实验的统计效率——如果所有实验都互斥,流量会被无限切分,每个实验的样本量都不够。

分流实现通常用用户 ID 的哈希:

import hashlib


def bucket_of(user_id: str, experiment_id: str, total_buckets: int = 1000) -> int:
    """把用户稳定地分到桶。

    用哈希而不是取模,保证不同实验的分桶互不相关,
    从而支持正交实验:同一个用户在不同实验里可以落到不同的桶。
    """
    digest = hashlib.md5(f"{experiment_id}:{user_id}".encode("utf-8")).digest()
    return int.from_bytes(digest[:4], "big") % total_buckets

实验参数怎么下发。排序服务不应该知道有哪些实验,它只认识「用户 ID 对应的参数」。实验平台负责把参数算好写进配置,排序服务按用户 ID 读取:

# 参数存储结构:按实验 ID 组织,每个实验下按用户分桶存参数
user_params:exp_alpha_test:{user_id} = { "alpha": 0.3, "beta": 0.4 }

这样做的解耦价值是:排序服务的代码不需要为任何实验改动,实验的配置和下线都是纯配置操作。

指标体系。混合排序的实验必须同时看三类指标:

类型指标说明
用户侧点击率、停留时长、留存率、完播率短期与长期的体验指标
内容侧长尾内容曝光占比、新创作者冷启动成功率生态健康度
商业侧广告填充率、eCPM、转化率商业化不受损
护栏侧负反馈率、内容重复投诉率、举报量出现严重退化时立即熔断

护栏指标是熔断条件,不是观察指标。如果护栏指标突破阈值,实验应该自动停止放量,而不是等分析人员发现。

from dataclasses import dataclass
from math import sqrt


@dataclass
class ExperimentResult:
    """实验结论。"""
    metric: str
    control_rate: float
    treatment_rate: float
    absolute_diff: float
    relative_diff: float
    z_score: float
    significant: bool
    guardrail_breached: bool


def analyze_two_proportion(
    metric: str,
    control_clicks: int,
    control_total: int,
    treatment_clicks: int,
    treatment_total: int,
    alpha: float = 0.05,
    guardrail_breached: bool = False,
) -> ExperimentResult:
    """两比例检验,判断实验组与对照组是否存在显著差异。"""
    p1 = control_clicks / control_total
    p2 = treatment_clicks / treatment_total

    # 合并比例,用于计算标准差
    pooled = (control_clicks + treatment_clicks) / (control_total + treatment_total)
    std_diff = sqrt(pooled * (1 - pooled) * (1 / control_total + 1 / treatment_total))

    z = (p2 - p1) / std_diff if std_diff > 0 else 0.0
    significant = abs(z) > 1.96

    return ExperimentResult(
        metric=metric,
        control_rate=p1,
        treatment_rate=p2,
        absolute_diff=p2 - p1,
        relative_diff=(p2 - p1) / p1 if p1 > 0 else 0.0,
        z_score=z,
        significant=significant,
        # 护栏一旦突破,无论主指标是否显著都判定为不可上线
        guardrail_breached=guardrail_breached,
    )

放量节奏:

  1. 离线回放。用历史请求数据回放候选策略,先排除明显变差的组合。这一步不产生线上流量,成本极低。
  2. 1% 流量。只验证工程正确性和系统开销,此时不看业务指标。
  3. 逐步放量。每一步放量后观察一个完整周期,确认主指标和护栏指标都正常再继续。
  4. 全量并保留对照组。全量后仍保留小比例对照组,用于持续观察。

必须避免的三种做法:

  • 同时改多个权重。如果一轮实验同时调整 α\alpha 和 β\beta,即使结果变好也不知道是哪个作用的结果,下一轮就无从下手。
  • 在实验期间修改参数。参数一变,实验就失效了。实验期间参数必须冻结,需要改就开新实验。
  • 只看短期指标。点击率上升可能伴随留存下降,实验周期必须覆盖完整的用户回访周期才能看清长期影响。

参数调优流程

1. 离线评估 → 2. 小流量测试 → 3. 全量发布 → 4. 持续监控
     │              │              │            │
     └──────────────┴──────────────┴────────────┘
                      迭代优化循环

案例分析

案例一:新闻热点排序

场景:突发新闻事件的内容排序

策略:

  • 提高时效性权重(α=0.3, β=0.2, γ=0.3, δ=0.2)
  • 加速时间衰减(λ=0.8)
  • 增加官方媒体加权(+0.3)

效果:热点内容 5 分钟内触达 80% 目标用户

案例二:长尾内容挖掘

场景:提升优质但低热度内容的曝光

策略:

  • 降低热度权重(α=0.3)
  • 提高质量分权重(内容完播率、收藏率)
  • 增加探索池比例(5% → 15%)

效果:长尾内容曝光提升 300%,创作者留存提升 25%

案例三:商业化平衡

场景:提升广告收入同时保持用户体验

策略:

  • 动态广告密度(根据用户耐受度调整)
  • 广告相关性加权(相关性×0.5 + eCPM×0.5)
  • 负反馈快速降权

效果:广告收入 +40%,用户投诉 -15%

最佳实践

权重配置建议

配置要点

  • 配置表达的是环境差异和运行参数,不是业务规则本身。

常见陷阱与规避

陷阱表现解决方案
权重过度拟合线上效果波动大定期回归测试,限制参数范围
信号泄露模型效果虚高严格区分训练/测试数据
冷启动恶化新用户/内容体验差建立独立的冷启动策略
多样性丧失信息茧房效应强制多样性约束,定期探索

总结

混合排序是热门内容系统的核心技术,需要在多个目标之间寻找平衡:

  1. 质量与数量的平衡 - 既要保证内容品质,又要保证内容充足
  2. 热点与长尾的平衡 - 既要抓住热点流量,又要挖掘长尾价值
  3. 个性与多样的平衡 - 既要满足用户偏好,又要避免信息茧房
  4. 体验与商业的平衡 - 既要优化用户体验,又要实现商业价值

成功的混合排序系统需要:

  • 清晰的信号分层架构
  • 灵活可配置的权重机制
  • 完善的监控和调优体系
  • 持续的实验和迭代优化

通过持续优化混合排序策略,可以显著提升平台的内容分发效率和用户满意度。

发现内容有问题?

告诉我们哪里需要改进。