多维热度计算

在真实的内容推荐系统中,单一维度的热度计算往往无法准确反映内容的质量和价值。我们需要综合考虑多个维度的数据,包括浏览量、点赞数、评论数、分享数等,来计算一个更加全面的热度分数。

为什么需要多维热度?

单一维度(如仅看浏览量)存在明显的局限性:

  • 浏览量容易被标题党操纵,无法反映内容质量
  • 点赞数反映用户认可度,但可能存在刷赞行为
  • 评论数体现用户参与度,但负面评论也会增加热度
  • 分享数代表内容传播价值,是最有价值的互动行为

通过多维度综合计算,我们可以:

  1. 降低单一数据被操纵的风险
  2. 更准确地评估内容的真实价值
  3. 鼓励高质量内容的产生和传播

核心维度解析

1. 浏览量 (Views)

浏览量是最基础的热度指标,代表内容的曝光程度。

特点:

  • 数据量最大,最容易获取
  • 容易被操纵(刷量)
  • 需要结合其他维度进行加权

2. 点赞数 (Likes)

点赞代表用户对内容的认可和喜爱。

特点:

  • 反映内容质量
  • 用户成本较低
  • 存在一定的刷赞可能

3. 评论数 (Comments)

评论体现用户的深度参与和互动意愿。

特点:

  • 用户参与成本较高
  • 反映内容的讨论价值
  • 需要注意区分正面/负面评论

4. 分享数 (Shares)

分享代表用户愿意将内容传播给他人,是最有价值的互动行为。

特点:

  • 用户成本最高
  • 代表内容的传播价值
  • 权重应该最高

权重设置策略

基础权重方案

权重方案的第一版不需要复杂,先用一组固定权重 + 归一化跑通链路,再谈动态调整。下表是一组可直接使用的起始配置:

维度符号权重选取依据
浏览量VV0.15采样成本最低、最容易被灌刷,只作为基础盘
点赞数LL0.20单次操作成本低,反映轻度的内容认可
评论数CC0.25需要用户投入文字,参与深度高于点赞
分享数SS0.40操作成本最高,直接带来新流量,权重最高

这组数字满足前面「权重设置原则」里的排序关系:分享 > 评论 > 点赞 > 浏览。四个权重相加为 1,这样不同业务线之间的分数可以直接横向比较,也方便在配置中心统一管理。

为什么要先归一化再加权:浏览量通常是分享量的百倍量级。如果直接对原始计数加权,浏览量一项就会贡献绝大部分分数,点赞、评论、分享的差异完全体现不出来,归一化把各维度压到同一量纲,加权才有意义。

下面是对应的权重配置与归一化实现:

from dataclasses import dataclass
from math import log1p

@dataclass(frozen=True)
class Weights:
    """各维度权重,四项之和必须为 1。"""
    view: float = 0.15
    like: float = 0.20
    comment: float = 0.25
    share: float = 0.40

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

    def as_dict(self) -> dict:
        return {
            "view": self.view,
            "like": self.like,
            "comment": self.comment,
            "share": self.share,
        }


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

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


def weighted_score(counts: dict, weights: Weights) -> float:
    """归一化后加权求和,返回加权热度(尚未叠加时间衰减)。"""
    weights.validate()
    return sum(
        weight * normalize(counts.get(dimension, 0))
        for dimension, weight in weights.as_dict().items()
    )

落地时的两个提醒:

  • 权重一定要配置化。写死在代码里的权重意味着每次调整都要发版,改一次权重引发的排名变化也无法和别的变更区分开。把权重放进配置中心,并记录每次修改的版本号,是后续做 A/B 实验的前提。
  • 权重之和为 1 不是硬性要求。如果把权重理解为「每单位行为贡献多少热度值」,就可以用整数语义(点赞 1、评论 3、分享 5)。归一化到 1 的好处是分数可跨业务比较,适合做统一监控和阈值判断。

权重设置原则

  1. 分享权重最高:分享行为成本最高,代表最强的认可
  2. 评论和点赞次之:反映用户参与度
  3. 浏览量权重最低:最容易获取,参考价值相对较低

动态权重调整

根据业务场景,可以进行动态权重调整:

固定权重解决了「怎么算」的问题,但解决不了「什么时候该换个算法」。不同业务阶段的内容生态不同,权重也应该跟着变。

三种调整维度:

维度依据调整幅度生效方式
业务阶段冷启动 / 成长 / 成熟 / 变现大配置中心切换
内容类型内容的行为分布和生命周期中按类型索引的参数表
实时流量近期各维度的互动占比小滑动窗口动态计算

业务阶段维度的调整:冷启动期评论和点赞更能反映内容质量(新内容还没有足够的播放量),变现期播放量成为主要指标。

from dataclasses import dataclass


@dataclass(frozen=True)
class Weights:
    """各维度权重,四项之和必须为 1。"""

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

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

    def as_dict(self) -> dict:
        return {
            "view": self.view,
            "like": self.like,
            "comment": self.comment,
            "share": self.share,
        }


# 各业务阶段的权重配置
STAGE_WEIGHTS = {
    "cold_start": Weights(view=0.15, like=0.30, comment=0.30, share=0.25),
    "growth": Weights(view=0.20, like=0.35, comment=0.25, share=0.20),
    "mature": Weights(view=0.15, like=0.35, comment=0.25, share=0.20),
    "monetization": Weights(view=0.35, like=0.30, comment=0.20, share=0.15),
}


def weights_for_stage(stage: str) -> Weights:
    """按业务阶段取权重,未知阶段回退到成熟期配置。"""
    weights = STAGE_WEIGHTS.get(stage, STAGE_WEIGHTS["mature"])
    weights.validate()
    return weights

内容类型维度的调整:同样是分享,短视频的分享是「转发给朋友」,深度长文的分享是「收藏式转发」,两者的持续时间完全不同。按类型索引一组参数就能解决,见后面的「不同内容类型的差异化处理」。

实时流量维度的调整是最灵活也最容易出问题的一种。它的思路是:观察最近一段时间各维度的实际互动占比,让权重向占比高的维度倾斜。

from collections import Counter


def dynamic_weights(events: list, min_weight: float = 0.10,
                    smoothing: float = 0.5) -> Weights:
    """根据近期互动分布动态计算权重。

    events 中每个元素包含 dimension 和 count 字段,
    dimension 取 view / like / comment / share。

    smoothing 是向基础权重回拉的力度:
    0 表示完全跟随实际分布,1 表示完全使用基础权重。
    取 0.5 意味着既反映实际分布,又不偏离基准太远。
    """
    base = Weights()
    base.validate()

    totals = Counter()
    for event in events:
        totals[event["dimension"]] += event["count"]

    grand_total = sum(totals.values())
    if grand_total <= 0:
        return base

    observed = {
        dimension: totals.get(dimension, 0) / grand_total
        for dimension in base.as_dict()
    }

    # 动态权重与基础权重按比例混合
    mixed = {
        dimension: smoothing * base_value + (1 - smoothing) * observed[dimension]
        for dimension, base_value in base.as_dict().items()
    }

    # 保底:任何一个维度都不能被压到下限以下
    mixed = {key: max(min_weight, value) for key, value in mixed.items()}

    # 归一化,保证权重之和为 1
    total = sum(mixed.values())
    normalized = {key: value / total for key, value in mixed.items()}

    return Weights(**normalized)

动态权重的四个前提:

  • 必须有下限。某个维度的占比跌到 0 不代表它不重要,只代表这一段时间恰好没有这类互动。把权重压到 0,等于让这个维度永久消失。
  • 必须有回拉。完全跟随实际分布会形成正反馈——分享多的内容权重高,权重高又让更多分享发生,最后只剩分享一个维度。smoothing 参数就是防止这件事的。
  • 窗口要够长。用最近几分钟的互动算权重,噪声太大,权重会来回跳。窗口至少覆盖一个完整的业务周期。
  • 必须可解释。动态权重每次算出来都不一样,排查问题时会非常困难。计算结果要连同当时的权重快照一起落库。

综合热度公式

基础公式

热度分数 = (浏览量 × Wv) + (点赞数 × Wl) + (评论数 × Wc) + (分享数 × Ws)

归一化处理

由于各维度的数据量级差异很大,需要先进行归一化处理:

归一化要解决的是一个具体的问题:浏览量的数量级通常是分享量的百倍。如果直接用原始计数加权,12000 × 0.15 = 1800 会把 95 × 0.40 = 38 完全淹没,四项权重的设置就失去了意义。

常见归一化方式的对比:

方式公式优点缺点适用
线性归一化(v - min) / (max - min)直观,结果落在 0 到 1依赖全局最大最小值,新内容接近 0数据分布稳定、量级接近
对数压缩log(1 + v)无需全局统计,新内容也有分高分段区分度下降计数型指标,默认首选
Z-Score(v - μ) / σ分布均匀,便于加权需要滑动窗口统计量需要做多指标融合时
分位数按历史分位映射抗异常值,分布均匀需要离线维护分位数表长尾极重的数据
比值v / 总互动数表示构成比例分母小时噪声大构成分析

为什么默认选对数压缩:它不依赖任何全局统计量,在线单条就能算;保留原始计数的大小关系;新内容即使只有个位数互动也能拿到非零分数。这三条正好命中了归一化最容易被忽略的三个坑。

from math import log1p, sqrt
from collections import deque


def normalize_log(value: int) -> float:
    """对数压缩:把长尾的原始计数压到同量级。

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


def normalize_minmax(value: int, minimum: int, maximum: int) -> float:
    """线性归一化:把值映射到 0 到 1。

    最大值与最小值相同时(所有值都一样),返回 0.5 而不是除以 0。
    """
    if maximum <= minimum:
        return 0.5
    return (value - minimum) / (maximum - minimum)


class ZScoreNormalizer:
    """基于滑动窗口的 Z-Score 归一化。

    用窗口内的均值和标准差做标准化,输出以 0 为中心的分值。
    适用于需要把多个分布完全不同的指标放到同一尺度上的场景。
    """

    def __init__(self, window: int = 1000):
        self.values = deque(maxlen=window)
        self._sum = 0.0
        self._sum_sq = 0.0

    def add(self, value: float) -> None:
        if len(self.values) == self.values.maxlen:
            old = self.values[0]
            self._sum -= old
            self._sum_sq -= old * old
        self.values.append(value)
        self._sum += value
        self._sum_sq += value * value

    def normalize(self, value: float) -> float:
        n = len(self.values)
        if n < 2:
            return 0.0
        mean = self._sum / n
        variance = (self._sum_sq - self._sum * self._sum / n) / (n - 1)
        sigma = sqrt(variance) if variance > 0 else 0.0
        if sigma == 0:
            return 0.0
        return (value - mean) / sigma

归一化处理的三条实践要点:

  • 归一化必须在加权之前。先加权再归一化,等于给各维度乘了不同的缩放系数,等于偷偷改了权重,而且极难排查。
  • 归一化系数要跟着内容一起算。用同一套系数处理所有内容,才能让分数之间可比。如果每条内容各算各的系数,最终分数就不具备横向比较的意义。
  • 归一化的结果要落库。保存归一化后的中间值而不只是最终分数,是为了排查时能回答「这条内容是哪个维度贡献了热度」。只存最终分数,排查就只能靠猜。

一个量级差异的直观例子:

原始计数:view=12000, like=860, comment=210, share=95

对数压缩后:view=9.39, like=6.76, comment=5.35, share=4.56
加权求和(0.15/0.20/0.25/0.40):
  view    9.39 × 0.15 = 1.41
  like    6.76 × 0.20 = 1.35
  comment 5.35 × 0.25 = 1.34
  share   4.56 × 0.40 = 1.82
  合计 = 5.92

如果不做归一化:
  view    12000 × 0.15 = 1800
  share      95 × 0.40 = 38
  分享的贡献只有浏览量的 2%,权重设置形同虚设

时间衰减因子

热度应该随时间衰减,新内容应该有更高的优先级:

时间衰减解决的是「历史累积量霸榜」的问题。一条三年前被大量点赞的内容,如果没有衰减,它的分数会永远压在今天的新内容前面——榜单就退化成了历史总榜。

三种衰减形式:

形式表达式特点适用
指数衰减e−λte^{-\lambda t}平滑、可导、无突变通用首选
线性衰减max⁡(0,1−t/T)\max(0, 1 - t/T)直观,到期直接归零有效期明确的运营位
对数衰减(t+1)−g(t + 1)^{-g}前期下降快、后期拖尾长长尾内容

指数衰减的形状最符合「热度自然消退」的直觉:初期下降快(用户注意力转移快),后期趋于平缓(长尾内容仍有少量流量)。

from math import exp


def time_decay_exponential(hours: float, lambda_per_hour: float = 0.05) -> float:
    """指数衰减因子。

    lambda_per_hour 的单位是「每小时」,越大衰减越快。
    """
    if hours <= 0:
        return 1.0
    return exp(-lambda_per_hour * hours)


def time_decay_linear(hours: float, total_hours: float) -> float:
    """线性衰减因子:到期直接归零。"""
    if hours <= 0:
        return 1.0
    if total_hours <= 0:
        return 0.0
    return max(0.0, 1.0 - hours / total_hours)


def time_decay_logarithmic(hours: float, gamma: float = 1.5) -> float:
    """对数衰减因子:前期下降快、后期拖尾长。"""
    if hours <= 0:
        return 1.0
    return pow(hours + 1.0, -gamma)

三种衰减的剩余比例对比(半衰期对齐到 6 小时):

经过时间指数衰减线性衰减对数衰减
1 小时97%83%49%
6 小时50%0%26%
24 小时12%0%16%
72 小时1.6%0%10%

这组数字说明了各自的适用面:线性衰减在 6 小时后归零,适合「运营位只展示 6 小时」这种明确期限的场景;对数衰减在 72 小时后仍保留 10%,适合需要长尾曝光的内容;指数衰减居中,是最常用的默认选择。

衰减系数怎么定:如果希望内容在 TT 小时后热度降到原来的 RR 比例,衰减系数可以反解出来:

λ=−ln⁡(R)T\lambda = -\frac{\ln(R)}{T}

例如希望内容在 12 小时后剩余 25%,则 λ=ln⁡(4)/12≈0.1155\lambda = \ln(4) / 12 \approx 0.1155。

衰减用在哪一层:在本页的完整公式里,衰减是作用在每个维度上的(λd\lambda_d 不同),而不是作用在加权求和之后。原因是不同行为的「保质期」差异很大——分享带来的流量是持续补充的,衰减可以慢;浏览量是瞬时消耗,不衰减就会让老内容仅凭历史浏览量长期霸榜。

完整的热度计算公式

把归一化、加权求和、时间衰减和质量系数串起来,完整公式为:

HeatScore(t)=∑dwd⋅log⁡(1+Vd)⋅q⋅exp⁡(−λdt)\text{HeatScore}(t) = \sum_{d} w_d \cdot \log(1 + V_d) \cdot q \cdot \exp(-\lambda_d t)

各符号的含义:

  • VdV_d:第 dd 个维度的原始计数(浏览、点赞、评论、分享等)
  • wdw_d:第 dd 个维度的权重,满足 ∑dwd=1\sum_d w_d = 1
  • log⁡(1+Vd)\log(1 + V_d):归一化后的维度值,用对数压缩长尾
  • qq:质量系数,反映内容本身和互动来源的可信程度
  • λd\lambda_d:该维度的衰减系数,不同维度的衰减速度可以不同
  • tt:内容发布至今经过的时间

之所以让每个维度带各自的衰减系数,是因为不同行为的「保质期」差异很大:分享带来的流量是持续补充的,衰减可以慢一些;而浏览量是瞬时消耗,不衰减就会让老内容仅凭历史浏览量长期霸榜。

单独把质量系数 qq 提出来,是为了避免它混在权重里变得不可解释。qq 的取值来自反作弊和内容审核,属于「这条内容的互动值不值得信」,而权重回答的是「哪种行为更重要」,两者的调整节奏完全不同。

对应的实现:

from dataclasses import dataclass
from math import exp, log1p


@dataclass(frozen=True)
class DimensionConfig:
    """单个维度的配置:权重与衰减系数。"""
    weight: float
    lambda_per_hour: float


@dataclass(frozen=True)
class MultiDimensionConfig:
    view: DimensionConfig
    like: DimensionConfig
    comment: DimensionConfig
    share: DimensionConfig
    min_score: float = 0.0

    def dimensions(self) -> dict:
        return {
            "view": self.view,
            "like": self.like,
            "comment": self.comment,
            "share": self.share,
        }


def heat_score(
    counts: dict,
    config: MultiDimensionConfig,
    quality: float,
    hours_since_publish: float,
) -> float:
    """计算内容的最终热度分数。

    :param counts: 各维度原始计数,键为 view/like/comment/share
    :param config: 权重与衰减配置
    :param quality: 质量系数,取值区间通常为 0 到 1.5
    :param hours_since_publish: 内容发布至今的小时数
    """
    if hours_since_publish < 0:
        # 时钟回拨:按刚刚发布处理,避免分数被放大
        hours_since_publish = 0.0

    total = 0.0
    for name, dim in config.dimensions().items():
        raw = counts.get(name, 0)
        if raw <= 0:
            continue
        normalized = log1p(raw)
        decay = exp(-dim.lambda_per_hour * hours_since_publish)
        total += dim.weight * normalized * decay

    score = total * quality
    return score if score > config.min_score else 0.0

调用示例(数值为示例,仅用于说明计算过程):

config = MultiDimensionConfig(
    view=DimensionConfig(weight=0.15, lambda_per_hour=0.05),
    like=DimensionConfig(weight=0.20, lambda_per_hour=0.08),
    comment=DimensionConfig(weight=0.25, lambda_per_hour=0.10),
    share=DimensionConfig(weight=0.40, lambda_per_hour=0.12),
)

score = heat_score(
    counts={"view": 12000, "like": 860, "comment": 210, "share": 95},
    config=config,
    quality=1.0,
    hours_since_publish=3,
)

完整流程示例

把上面的公式放进真实链路,一条内容的热度计算会依次经过下面几步。注意顺序很重要:先清洗、再归一化、后加权、最后衰减,任何一步调换都会得到错误的结果。

步骤处理内容输出关键点
1. 采集原始行为事件写入 Kafka事件流必须带上事件时间,不能用消费时间
2. 防刷过滤按用户、设备、IP 聚合判定异常清洗后的计数异常行为的权重直接置 0,不参与后续计算
3. 归一化对每个维度的计数做对数压缩同量纲的维度值压缩后仍保持原始大小关系
4. 加权求和各维度值乘以权重后求和加权热度权重来自配置中心,带版本号
5. 乘质量系数叠加反作弊与审核结论可信热度质量系数取值范围需要有上下限
6. 时间衰减按内容类型乘衰减因子当前热度衰减系数按内容类型分别配置
7. 写入榜单更新 Redis ZSet 的分数最新排名写入用 ZADD 批量,避免逐条往返

以一条示例内容为例,走完整个流程:

# 步骤 2:防刷过滤后保留下来的有效计数
counts = {"view": 12000, "like": 860, "comment": 210, "share": 95}

# 步骤 3:归一化
normalized = {name: log1p(value) for name, value in counts.items()}
# 示例结果:view ≈ 9.39,like ≈ 6.76,comment ≈ 5.35,share ≈ 4.56

# 步骤 4:加权求和
weighted = sum(
    normalized[name] * config.dimensions()[name].weight for name in counts
)
# 示例结果:≈ 5.92

# 步骤 5:质量系数(内容通过审核、互动来源正常,示例取 1.0)
quality = 1.0

# 步骤 6:时间衰减(发布 3 小时,各维度按各自系数衰减)
decayed = sum(
    normalized[name]
    * config.dimensions()[name].weight
    * exp(-config.dimensions()[name].lambda_per_hour * 3)
    for name in counts
) * quality
# 示例结果:≈ 4.54

# 步骤 7:写入榜单
# ZADD hot:ranking:news 4.54 content:10086

这条链路上有三个容易出问题的地方:

  • 步骤 1 的事件时间。如果用消费时间代替事件时间,延迟到达的分享事件会被算成「刚刚发生」,内容热度会出现跳变。
  • 步骤 3 与步骤 4 的顺序。先加权再归一化等价于对各维度乘了不同的缩放系数,等于偷偷改了权重,很难排查。
  • 步骤 6 的写入时机。衰减是连续函数,如果每隔固定时间对全量内容重算再全量写入,写入量会非常大。实践中只在内容有新互动或到达刷新周期时才更新对应条目。

实际应用注意事项

1. 防刷机制

多维热度的一个前提是:参与加权的计数必须是真实的。只要有一个维度被灌刷,加权求和的结果就会被拉偏,而权重越高、影响越大。

维度常见作弊手法检测手段处置方式
浏览量脚本刷 PV、批量点击设备/IP 去重、请求间隔方差过小异常请求不计数
点赞数集中时间批量点赞点赞时间分布熵过低、单位时间速率超阈值点赞权重打折或置 0
评论数模板化灌水评论文本重复率、账号注册时间聚集过滤重复评论,不计入统计
分享数诱导分享、分享链路作弊分享来源域名白名单、跳转链路校验不计入热度

其中时间分布熵是最有效的通用信号。正常用户的互动时间分布在一天之中,熵较高;刷量行为的互动时间高度集中在极短的区间内,熵显著偏低。可以对「某个内容在某个时间桶内的互动占比」做熵计算,低于阈值就判定为可疑。

实现上有三个原则:

  1. 过滤要在加权之前做。在加权之后再”修正分数”,很难说清楚修正了多少、依据是什么;直接不计入可疑计数,链路更干净。
  2. 判定阈值要可配置且带灰度。不同业务的正常互动密度差异很大,阈值应该按内容类型配置,并且先以「只打标不拦截」的方式跑一段时间,观察误伤率。
  3. 保留原始数据。被过滤掉的计数也要落库,用于事后分析作弊趋势和回溯误判,否则每次策略调整都只能靠猜。

2. 冷启动处理

对于新发布的内容,可以适当降低时间衰减的影响:

冷启动要解决的问题是:新内容刚发布时累计互动几乎为零,按标准公式算出的热度接近 0,它永远进不了榜单,也就永远拿不到互动——这是个死循环。

三种打破死循环的手段:

手段做法生效范围退出条件
衰减豁免冷启动期内不衰减或减速衰减发布后 N 小时时间到期自动退出
探索曝光给固定量的小流量曝光发布后 M 次曝光达到 M 次后退出
热度保底分数低于下限时抬到下限发布后 N 小时时间到期自动退出

三种手段的共同点是都有一个明确的退出条件。没有退出条件的扶持会让「冷启动」变成永久保护,劣质内容反而霸占着位置。

衰减豁免是最直接的实现。它改变的是衰减函数的参数,而不是在结果上做修正:

from math import exp, log1p

# 冷启动期时长(小时),期内时间衰减不生效
COLD_START_HOURS = 6


def heat_score_with_cold_start(
    counts: dict,
    weights: dict,
    lambda_per_hour: float,
    hours_since_publish: float,
    cold_start_hours: float = COLD_START_HOURS,
) -> float:
    """带冷启动处理的热度计算。

    冷启动期内不做时间衰减:这段时间内容几乎没有自然互动,
    衰减会让分数直接归零,内容永远拿不到第一次曝光。
    """
    total = 0.0
    for dimension, weight in weights.items():
        raw = counts.get(dimension, 0)
        if raw <= 0:
            continue

        if hours_since_publish < cold_start_hours:
            # 冷启动期内不衰减
            decay = 1.0
        else:
            # 超出冷启动期后,从冷启动期结束时开始计算衰减,
            # 这样衰减是连续的,不会出现突然的分数跳变
            effective_hours = hours_since_publish - cold_start_hours
            decay = exp(-lambda_per_hour * effective_hours)

        total += weight * log1p(raw) * decay

    return total

连续性是这里的关键。如果冷启动期结束后直接按「从发布时刻算起」的公式算热度,分数会在跨过 6 小时的那一刻突然掉一截——一条内容在 5 分 59 秒和 6 分 01 秒的分数相差很大。这种跳变在榜单上表现为内容莫名下沉。上面用「从冷启动期结束时开始算衰减」的方式保证了连续。

热度保底是另一种思路:不管算出来是多少,只要内容还在冷启动期,分数就不低于某个下限。

# 冷启动期内的分数下限
COLD_START_MIN_SCORE = 0.5


def apply_cold_start_floor(score: float, hours_since_publish: float,
                           cold_start_hours: float = COLD_START_HOURS,
                           floor: float = COLD_START_MIN_SCORE) -> float:
    """冷启动期内的分数保底。

    分数低于下限时抬到下限;超出冷启动期后不再干预,
    由正常的衰减把分数自然带下去。
    """
    if hours_since_publish < cold_start_hours:
        return max(score, floor)
    return score

保底值不能设得太高。保底太低起不到作用,太高会让一批内容挤在同一个分数上,榜单的顶部就没有区分度了。0.5 这个量级意味着「刚好够进入榜单末尾」。

探索曝光配合冷启动使用,效果比单独用衰减豁免更好。它让内容获得一段真实的用户反馈,而不是靠分数硬抬位置。

冷启动流程:
1. 内容发布,进入冷启动池
2. 分配 500 次曝光,分散给不同用户
3. 观察互动率:完播率、点赞率
4. 达标(互动率 > 3%)→ 进入正常排序,由分数决定位置
5. 未达标 → 延长冷启动期,最多延长 3 次
6. 仍未达标 → 退出冷启动池,按普通内容处理

冷启动期结束后必须有清算。最常见的错误是:内容在冷启动期拿到了保底分数,进了榜,然后冷启动期一结束分数暴跌,用户刚点进去就发现它掉下去了。这个体验损伤比它当初获得的那点曝光更严重。

三个容易被忽略的细节:

细节原因
冷启动期要按内容类型分别配置新闻的起量窗口是分钟级,长文可能需要几小时
保底分数不能进入榜单的头部保底内容排在前面会挤掉真正的热门内容
冷启动内容要打标统计「榜单真实内容占比」时,冷启动内容不应计入

3. 不同内容类型的差异化处理

不同内容类型的行为分布和生命周期差异很大,用同一套权重和衰减系数通常不是最优选择。可以在同一套框架下,为每种内容类型配置一组参数。

内容类型浏览量权重分享权重衰减系数调整依据
新闻资讯调高保持调快时效性极强,浏览量能反映传播速度,衰减需快以便热点快速更替
短视频调高调高中等消费以播放为主,完播和转发是主要传播路径
深度长文调低调低调慢收藏和读完是主要价值信号,浏览量参考价值低
图集保持保持略快互动成本介于图文与视频之间,生命周期偏短
直播/活动调高保持极快强时效场景,内容在结束后应立即退出榜单

实现上不需要为每种类型写一套代码,只要把权重和衰减系数抽成按类型索引的配置:

# 按内容类型索引的参数表,配置下发后可在不重启的情况下生效
CONTENT_TYPE_PARAMS = {
    "news": {
        "weights": {"view": 0.25, "like": 0.20, "comment": 0.20, "share": 0.35},
        "lambda_per_hour": 0.25,
    },
    "video": {
        "weights": {"view": 0.30, "like": 0.20, "comment": 0.15, "share": 0.35},
        "lambda_per_hour": 0.08,
    },
    "article": {
        "weights": {"view": 0.10, "like": 0.25, "comment": 0.30, "share": 0.35},
        "lambda_per_hour": 0.02,
    },
}


def config_for(content_type: str, base: MultiDimensionConfig) -> MultiDimensionConfig:
    """按内容类型调整权重,其余参数沿用基础配置。"""
    override = CONTENT_TYPE_PARAMS.get(content_type)
    if override is None:
        return base
    weights = override["weights"]
    return MultiDimensionConfig(
        view=DimensionConfig(weights["view"], base.view.lambda_per_hour),
        like=DimensionConfig(weights["like"], base.like.lambda_per_hour),
        comment=DimensionConfig(weights["comment"], base.comment.lambda_per_hour),
        share=DimensionConfig(weights["share"], base.share.lambda_per_hour),
    )

需要注意的两点:

  • 参数是起点不是结论。上表中的权重和衰减系数是按各类内容的典型行为模式给出的推荐区间,具体取值应该用历史数据回放加 A/B 实验确定。
  • 类型划分要足够稳定。内容类型的判定如果经常变动,同一条内容会在不同参数下反复跳动,榜单看起来就会抖。建议用内容发布时确定的类型并缓存下来,避免每次计算都重新判定。

总结

多维热度计算是内容推荐系统的核心算法之一。通过综合考虑浏览量、点赞、评论、分享等多个维度,并配合合理的权重设置和时间衰减机制,我们可以更准确地评估内容的真实价值和热度。

关键要点:

  1. 多维度综合:不要依赖单一指标
  2. 合理权重:分享 > 评论 ≈ 点赞 > 浏览
  3. 时间衰减:新内容应有优先展示机会
  4. 归一化处理:消除量级差异
  5. 防刷机制:识别和处理异常数据

在实际应用中,还需要根据具体业务场景不断调整和优化参数,以达到最佳效果。

发现内容有问题?

告诉我们哪里需要改进。