动态权重调整

动态权重调整是反作弊系统中的核心机制之一。通过实时监控用户行为、内容质量和互动模式,系统可以动态调整各项指标的权重,有效识别和抑制异常行为。

一、为什么需要动态权重

1.1 静态权重的局限性

在传统的排名系统中,各项指标通常采用固定权重:

问题:

  • 无法应对刷量作弊行为
  • 无法适应不同内容类型的特性
  • 无法响应用户行为模式的变化
  • 容易被攻击者找到规律并利用

1.2 动态权重的优势

特性静态权重动态权重
抗作弊能力弱强
适应性低高
可解释性高中
实现复杂度低高
实时性无支持

二、动态权重调整的核心原理

2.1 权重调整的信号源

动态权重系统依赖多种信号源进行决策:

┌─────────────────────────────────────────────────────────────┐
│                    信号源分类                                │
├─────────────────────────────────────────────────────────────┤
│  用户行为信号    │  内容质量信号    │  时间维度信号          │
│  ─────────────   │  ─────────────   │  ─────────────         │
│  • 互动频率      │  • 完播率        │  • 发布时间            │
│  • 互动分布      │  • 跳出率        │  • 热度衰减            │
│  • 账号画像      │  • 举报率        │  • 周期波动            │
│  • 设备指纹      │  • 审核结果      │  • 趋势变化            │
└─────────────────────────────────────────────────────────────┘

2.2 权重计算模型

前面列出的信号源(用户行为、内容质量、时间维度)最终都要落到一个可计算的权重上。推荐的模型是乘性分解:

wfinal=wbase×ftrust(u)×ftime(u,t)×fanomaly(u,c)w_{final} = w_{base} \times f_{trust}(u) \times f_{time}(u, t) \times f_{anomaly}(u, c)

各因子的职责:

因子含义取值范围数据来源
wbasew_{base}该行为类型的基础权重固定值配置中心
ftrustf_{trust}用户信誉系数0 到 1.5账号画像服务
ftimef_{time}时间系数0.5 到 1.2行为时间戳
fanomalyf_{anomaly}异常检测系数0 到 1异常检测服务

为什么用乘性而不是加性:

  • 乘性天然表达「否决」语义。任何一个因子判定该行为不可信时,乘积可以直接归零;而加性模型需要为每个否决场景单独设计惩罚项,组合起来容易出现负分。
  • 乘性便于解释。可以把最终权重拆开,告诉运营「这次互动基础权重是 1,信誉系数 0.8,时间系数 1.1,异常系数 1,最终 0.88」;加性模型拆解后各项之间还可能互相抵消,反而更难解释。
  • 乘性各因子之间解耦。新增一个信号源只需要增加一个因子,不需要改动已有的权重配置。

乘性模型的副作用也要清楚:多个小于 1 的因子会连乘衰减。信誉系数 0.5 叠加异常系数 0.4,最终只剩 0.2,等于把该用户的行为几乎完全抹掉。这通常是期望的行为(重度可疑用户的行为本来就不该计入),但要设置一个下限,避免极端情况下降权过度:

from dataclasses import dataclass
from math import exp

# 各因子的取值下限,防止多项连乘导致权重过度衰减
MIN_TRUST_FACTOR = 0.1
MIN_TIME_FACTOR = 0.5
MIN_ANOMALY_FACTOR = 0.0
MAX_TRUST_FACTOR = 1.5
MAX_TIME_FACTOR = 1.2


@dataclass(frozen=True)
class WeightFactors:
    """一次权重计算涉及的全部因子。"""

    base_weight: float        # 行为类型的基础权重
    trust_factor: float       # 用户信誉系数
    time_factor: float        # 时间系数
    anomaly_factor: float     # 异常检测系数

    def clamped(self) -> "WeightFactors":
        """把每个因子收敛到允许区间内。"""
        return WeightFactors(
            base_weight=max(0.0, self.base_weight),
            trust_factor=min(MAX_TRUST_FACTOR, max(MIN_TRUST_FACTOR, self.trust_factor)),
            time_factor=min(MAX_TIME_FACTOR, max(MIN_TIME_FACTOR, self.time_factor)),
            anomaly_factor=max(MIN_ANOMALY_FACTOR, min(1.0, self.anomaly_factor)),
        )

    def final_weight(self) -> float:
        f = self.clamped()
        return f.base_weight * f.trust_factor * f.time_factor * f.anomaly_factor


# 基础权重表:不同行为类型的基础权重
BASE_WEIGHTS = {
    "view": 1.0,
    "like": 3.0,
    "comment": 5.0,
    "share": 8.0,
}

clamped() 这一步不可省略。因子来自多个独立服务,任何一个服务的异常返回(比如返回 null 被当成 0,或者返回了超出预期的极大值)都会污染最终权重。在计算入口做统一的区间收敛,比在每个调用方分别处理要可靠得多。

三、实现方案

3.1 基于信誉分的权重调整

信誉分回答的是「这个账号的行为值不值得采信」。它是账号维度的长期属性,需要独立于单次行为持续维护。

信誉分通常由若干个正负因子累加得到,再映射到 0 到 100 的区间:

R=50+∑isi⋅piR = 50 + \sum_i s_i \cdot p_i

其中 sis_i 是因子得分,pip_i 是该因子的权重系数。然后按信誉分档位映射到权重系数:

信誉分区间账号画像权重系数 ftrustf_{trust}说明
0 到 20高风险账号0.1几乎不采信其行为
20 到 40可疑账号0.3显著降权
40 到 60普通新账号0.5新注册账号缺乏历史行为
60 到 80普通账号1.0基准
80 到 100高活跃可信账号1.2 到 1.5行为更有参考价值
class ReputationService:
    """用户信誉分服务。"""

    # 各因子的得分与权重系数
    FACTOR_WEIGHTS = {
        "account_age_days": 0.10,
        "verified": 0.20,
        "historical_report_rate": -0.60,
        "past_violations": -0.50,
        "behavior_diversity": 0.15,
    }

    def score(self, user_profile: dict) -> float:
        """计算信誉分,返回 0 到 100 的数值。"""
        score = 50.0
        for factor, coefficient in self.FACTOR_WEIGHTS.items():
            score += user_profile.get(factor, 0) * coefficient
        return max(0.0, min(100.0, score))

    def trust_factor(self, user_profile: dict) -> float:
        """把信誉分映射为权重系数。"""
        score = self.score(user_profile)
        if score < 20:
            return 0.1
        if score < 40:
            return 0.3
        if score < 60:
            return 0.5
        if score < 80:
            return 1.0
        # 80 到 100 区间线性映射到 1.2 到 1.5
        return 1.2 + (score - 80) / 20 * 0.3

信誉分的几个设计要点:

  • 信誉分和异常分是两种东西。信誉分是账号的长期画像,反映的是「这个账号本身可不可信」;异常分是针对某一次具体行为的判定,反映的是「这次互动像不像作弊」。两者都影响权重,但来源、时效性和更新频率都不同,不要混用一个分数。
  • 举报率是双向的。举报率高说明账号行为惹人厌,是负向因子;但也要防止恶意举报——竞争对手举报优质作者会污染信誉分,因此举报率需要设置上限,不能无限扣分。
  • 信誉分要平滑更新。直接用当前分数会让权重在两个档位之间跳变。可以维护一个指数移动平均,或者对分档做滞后处理(升级立即生效,降级需要连续多日低于阈值)。
  • 信誉分要用在「采信程度」而不是「惩罚程度」上。信誉高的用户行为权重更高是合理的,但反过来看,信誉低的用户不应该被完全禁止参与——那会把新用户和小众内容创作者排除在外。降权比封禁更合适。

3.2 基于时间衰减的动态权重

时间系数解决的是另一个问题:同样一次互动,发生在什么时候,可信度不同。典型的场景是账号集中注册后立刻开始高频互动,或者一条内容在极短时间内的互动量异常高。

时间系数的设计目标是:越密集的连续行为,单位权重越低。这与内容热度的时间衰减是同一个数学形式,但作用对象不同——热度衰减衡量的是「内容有多新」,权重时间衰减衡量的是「这批行为有多可疑」。

一个常见做法是按该用户最近一次互动到本次互动的时间间隔来调整:间隔越短,说明是自动化程序连续触发,权重越低。

from math import exp

# 间隔越短,系数越低;间隔越长,系数越接近上限
MIN_INTERVAL_SECONDS = 2.0
MAX_TIME_FACTOR = 1.2


def time_factor(seconds_since_last_action: float, action_count_in_window: int = 0) -> float:
    """基于行为间隔的时间系数。

    两个参数共同决定系数:
    - 间隔越短越可疑:连续触发几乎没有间隔的通常是脚本;
    - 窗口内次数越多越可疑:说明是持续性的批量行为。
    """
    if seconds_since_last_action <= 0:
        return MIN_TIME_FACTOR

    # 间隔越短系数越低,用指数形式在 0 到 1 之间平滑过渡
    interval_score = exp(-seconds_since_last_action / 60.0)

    # 次数因子:1 次行为不额外惩罚,超过阈值后快速下降
    count_penalty = 1.0
    if action_count_in_window > 10:
        count_penalty = max(0.3, 10.0 / action_count_in_window)

    factor = (1.0 - interval_score) * (1.0 - MIN_TIME_FACTOR) + MIN_TIME_FACTOR
    return min(MAX_TIME_FACTOR, factor * count_penalty)

除了「间隔」之外,时间维度还有两类信号值得考虑:

  • 行为是否跨越了自然活动时段。凌晨三点的连续互动比白天的连续互动更可疑。这需要维护用户的历史活跃时段分布,属于画像的一部分。
  • 行为发生的时间点是否与内容发布节奏吻合。如果一条内容在发布后的几秒内就获得了大量互动,而这类内容正常情况下需要几分钟才有反馈,这种”瞬时同质化”是刷量的典型特征。

这个因子的副作用:正常用户快速连续操作(比如连续点赞十条)也会被判为低权重。缓解办法是对交互密集型内容放宽阈值——点赞十个内容是正常行为,但在一条投票类内容上连续投票十次就需要警惕。不同内容类型的正常操作节奏本来就不一样,阈值应该分类目配置。

3.3 基于异常检测的权重调整

异常检测给出的是一次具体行为的可疑程度,直接映射为权重系数:

异常分数区间判定权重系数 fanomalyf_{anomaly}处置
0 到 0.3正常1.0正常计入热度
0.3 到 0.6轻度可疑0.6计入但打折
0.6 到 0.9高度可疑0.2基本不计入
0.9 以上判定为作弊0完全不计入,并触发处置流程
class AnomalyWeightAdjuster:
    """把异常检测的输出映射为权重系数。"""

    # 分数区间与系数的映射,按分数降序定义
    BANDS = [
        (0.9, 0.0),
        (0.6, 0.2),
        (0.3, 0.6),
        (0.0, 1.0),
    ]

    def factor(self, anomaly_score: float) -> float:
        """异常分数映射为权重系数。"""
        score = max(0.0, min(1.0, anomaly_score))
        for threshold, factor in self.BANDS:
            if score >= threshold:
                return factor
        return 1.0

    def adjust(self, base_weight: float, anomaly_score: float, trust_factor: float,
               time_factor: float) -> float:
        """综合计算最终权重。"""
        factors = WeightFactors(
            base_weight=base_weight,
            trust_factor=trust_factor,
            time_factor=time_factor,
            anomaly_factor=self.factor(anomaly_score),
        )
        return factors.final_weight()

这一层与「异常评分系统」的关系:异常检测模块负责产出 0 到 1 的异常分数,权重调整模块只负责把这个分数翻译成权重系数。两者的职责必须分开——如果把阈值逻辑直接写在权重计算里,每换一个检测算法就要改一遍权重代码。

处置的边界要清楚:

  • 权重调整层只调整权重,不做封禁。把权重降到 0 和把账号封禁是完全不同的处置,权限应该分离。权重层只负责「这次互动值多少分」,是否封禁由处置系统根据多个信号综合判断。
  • 异常分数为 0 的权重是 0,不是负数。乘性模型下不会出现负权重,这一点很重要:负权重会让内容热度变成负值,污染整个榜单的排序。

四、完整的权重调整系统

4.1 权重调整引擎

把三部分实现整合成一个引擎。关键设计是分层缓存 + 批量计算:信誉分和异常分来自不同的服务,调用成本高,必须缓存;权重计算本身很轻量。

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 权重调整引擎。
 *
 * 分层职责:
 * - 信誉分来自账号画像服务,按用户缓存;
 * - 异常分来自异常检测服务,按行为键缓存;
 * - 权重合成是纯计算,不做 I/O。
 */
public class WeightAdjustmentEngine {

    /** 行为上下文。 */
    public record BehaviorContext(
            String userId,
            String contentId,
            String behaviorType,
            long occurredAtMillis,
            double trustFactor,
            double timeFactor,
            double anomalyScore
    ) {}

    /** 权重计算结果,包含可解释的中间量。 */
    public record WeightResult(
            String userId,
            String contentId,
            String behaviorType,
            double baseWeight,
            double trustFactor,
            double timeFactor,
            double anomalyFactor,
            double finalWeight,
            String reason
    ) {}

    private final Map<String, Double> baseWeights;
    private final double minTrustFactor = 0.1;
    private final double maxTrustFactor = 1.5;
    private final double minTimeFactor = 0.5;
    private final double maxTimeFactor = 1.2;

    /** 异常分数到系数的映射区间,按分数降序排列。 */
    private final double[][] anomalyBands = {
            {0.9, 0.0},
            {0.6, 0.2},
            {0.3, 0.6},
            {0.0, 1.0},
    };

    public WeightAdjustmentEngine(Map<String, Double> baseWeights) {
        this.baseWeights = Map.copyOf(baseWeights);
    }

    /**
     * 计算单次行为的最终权重。
     */
    public WeightResult calculate(BehaviorContext context) {
        double base = baseWeights.getOrDefault(context.behaviorType(), 0.0);

        double trust = clamp(context.trustFactor(), minTrustFactor, maxTrustFactor);
        double time = clamp(context.timeFactor(), minTimeFactor, maxTimeFactor);
        double anomaly = anomalyFactor(context.anomalyScore());

        double finalWeight = base * trust * time * anomaly;

        return new WeightResult(
                context.userId(),
                context.contentId(),
                context.behaviorType(),
                base, trust, time, anomaly, finalWeight,
                buildReason(base, trust, time, anomaly));
    }

    /**
     * 批量计算。同一个用户的信誉因子在批次内复用,避免重复读取。
     */
    public Map<String, WeightResult> calculateBatch(java.util.List<BehaviorContext> contexts) {
        Map<String, WeightResult> results = new ConcurrentHashMap<>();
        for (BehaviorContext context : contexts) {
            String key = context.userId() + ":" + context.contentId() + ":" + context.occurredAtMillis();
            results.put(key, calculate(context));
        }
        return results;
    }

    /**
     * 异常分数映射为权重系数。
     */
    private double anomalyFactor(double score) {
        double clamped = clamp(score, 0.0, 1.0);
        for (double[] band : anomalyBands) {
            if (clamped >= band[0]) {
                return band[1];
            }
        }
        return 1.0;
    }

    private double clamp(double value, double min, double max) {
        if (Double.isNaN(value)) {
            // 上游返回非法值时退回中性取值,避免污染最终权重
            return min;
        }
        return Math.max(min, Math.min(max, value));
    }

    /**
     * 构造可解释的原因文本,直接用于审计日志和申诉回复。
     */
    private String buildReason(double base, double trust, double time, double anomaly) {
        return String.format(
                "base=%.2f trust=%.2f time=%.2f anomaly=%.2f",
                base, trust, time, anomaly);
    }
}

引擎的几个关键点:

  • 因子取值要做区间收敛。clamp 方法同时处理了越界和 NaN 两种情况。上游服务返回 NaN 是很常见的情况(计算异常时浮点运算的结果),如果不拦住,NaN 会沿着乘积扩散,最终污染整个榜单的分数,而且极难排查。
  • 必须返回中间量。WeightResult 里保留了 base、trust、time、anomaly 四个中间因子,而不只是最终权重。没有这些中间量,运营收到申诉时无法解释「为什么这次投票只算了 0.1 分」。
  • 异常系数为 0 时直接短路。当异常系数为 0 时,最终权重必然为 0,可以提前返回,省掉后续计算。

4.2 实时权重更新策略

权重调整要在实时链路上生效,就必须在「每次行为都重新计算」和「权重变化有延迟」之间做取舍。常见的策略有三种:

策略做法优点缺点
逐事件计算每条行为到达时实时计算权重最实时,响应作弊最快依赖下游服务,链路延迟叠加
批量窗口计算攒一个短窗口统一计算摊薄下游调用开销权重生效有窗口级延迟
预计算 + 增量修正定期算好基线权重,异常时即时修正常规路径开销最低需要维护两套逻辑

推荐以批量窗口为主、异常即时修正为辅。具体来说:

  • 常规行为走批量窗口。正常用户的绝大多数行为不会触发异常检测,把它们放进一个几秒的窗口统一处理,可以把对信誉分、异常分服务的调用量摊薄一个数量级。
  • 明确命中作弊规则的行为立即处理。规则命中的判定是确定性的、零延迟的,不需要等窗口,直接把权重置 0 并触发后续处置。
  • 信誉分按用户缓存。一个用户在一个窗口内可能产生多次互动,信誉分只取一次,不要每次都去查。
/**
 * 实时权重更新器:批量窗口 + 异常即时修正。
 */
public class RealtimeWeightUpdater {

    private final WeightAdjustmentEngine engine;
    private final ReputationClient reputationClient;
    private final AnomalyClient anomalyClient;

    /** 窗口内待处理的行为。 */
    private final List<BehaviorContext> pending = new ArrayList<>();

    public RealtimeWeightUpdater(
            WeightAdjustmentEngine engine,
            ReputationClient reputationClient,
            AnomalyClient anomalyClient) {
        this.engine = engine;
        this.reputationClient = reputationClient;
        this.anomalyClient = anomalyClient;
    }

    /**
     * 处理一条行为。命中确定性的作弊规则时立即降权并返回。
     */
    public WeightResult onBehavior(BehaviorContext raw) {
        // 规则命中是确定性的,走快速通道,不等窗口
        if (raw.anomalyScore() >= 1.0) {
            return engine.calculate(raw);
        }

        // 其余行为进入窗口批量处理
        synchronized (pending) {
            pending.add(raw);
        }
        return null;
    }

    /**
     * 窗口关闭时批量计算并写出结果。
     */
    public List<WeightResult> flush() {
        List<BehaviorContext> batch;
        synchronized (pending) {
            if (pending.isEmpty()) {
                return List.of();
            }
            batch = new ArrayList<>(pending);
            pending.clear();
        }

        // 同一用户的信誉分只取一次
        Map<String, Double> trustCache = new HashMap<>();
        List<WeightContext> resolved = new ArrayList<>(batch.size());
        for (BehaviorContext context : batch) {
            double trust = trustCache.computeIfAbsent(
                    context.userId(),
                    id -> reputationClient.trustFactor(id));
            resolved.add(context.withTrustFactor(trust));
        }

        List<WeightResult> results = new ArrayList<>(resolved.size());
        for (BehaviorContext context : resolved) {
            results.add(engine.calculate(context));
        }
        return results;
    }
}

还有几条关于实时性的实践建议:

  • 权重更新和热度写入要解耦。权重的变化不应该立刻触发一次榜单重排,否则异常检测的抖动会直接反映为榜单抖动。合理做法是权重先更新到内容分数上,榜单按既有的刷新周期统一重排。
  • 配置变更要能快速生效。阈值、基础权重这些参数必须支持热更新。发现问题时,运营希望的是「调一下参数立刻生效」,而不是走一次发版流程。
  • 给实时链路设定明确的延迟预算。从行为发生到权重生效,这个链路上的每一环都要有延迟指标。当总延迟超出预算时,需要能主动降级——例如跳过异常检测这一环,只用信誉分做粗粒度调整。

五、最佳实践

5.1 权重调整的平滑处理

避免权重突变导致排名剧烈波动:

权重的本质是一个会变的乘数。一旦它跳变,内容的热度分数就跟着跳变,榜单随之抖动——用户会看到某条内容莫名其妙地掉出前十,而运营完全说不清发生了什么。因此权重的变化率本身也要被当作一个需要控制的量。

三类会导致突变的情况:

触发原因表现后果
信誉分跨越档位权重系数从 1.0 直接跳到 0.3该用户的互动瞬间大面积缩水
异常检测误判异常分数从 0.2 跳到 0.95,系数从 1.0 归 0内容热度断崖式下跌
单次大额互动权重加成从 1.0 跳到 2.0榜单头部被单条内容占据

对应的三种平滑手段:

第一层:信誉分档位滞后。 升级立即生效,降级需要连续多日低于阈值才触发。这解决的是「长期表现突然变差」的情况——用户偶尔的一次异常行为不应该立刻把长期信誉打回原形。

第二层:异常系数做时间平滑。 不直接用当前异常分数,而是用它的指数移动平均:

from dataclasses import dataclass
from math import exp

# 平滑系数:越小越平滑,但对新的作弊行为的反应也越慢
SMOOTHING_ALPHA = 0.3


@dataclass
class AnomalySmoother:
    """对异常分数做指数平滑。

    异常检测的输出本身有抖动,直接用它会让权重跳变。
    平滑之后,判定从「正常」到「作弊」需要连续几帧确认,
    相应地,从「作弊」恢复为「正常」也慢一些。
    """

    alpha: float
    smoothed: float = 0.0
    initialized: bool = False

    def update(self, anomaly_score: float) -> float:
        """输入当前异常分数,返回平滑后的分数。"""
        score = max(0.0, min(1.0, anomaly_score))
        if not self.initialized:
            self.initialized = True
            self.smoothed = score
            return self.smoothed

        self.smoothed = self.alpha * score + (1 - self.alpha) * self.smoothed
        return self.smoothed


def change_rate(previous: float, current: float) -> float:
    """变化率:当前值相对上一次变化的幅度。

    用于判断一次调整是否越过了「允许的最大跳变幅度」。
    """
    if previous <= 0:
        return 0.0 if current <= 0 else 1.0
    return abs(current - previous) / previous

第三层:对单次调整的幅度设上限。 无论算出多大的权重变化,一次只允许走完一部分,剩下的留给下一次窗口:

# 单次权重调整允许的最大相对变化幅度
MAX_CHANGE_RATE = 0.25


def clamp_weight_change(previous_weight: float, target_weight: float) -> float:
    """把权重变化限制在单次允许的幅度内。

    权重下降和上升用不同的上限:下降(降权)应该快,
    上升(恢复)应该慢,否则一次误判解除就会让作弊账号立刻回到榜单。
    """
    if previous_weight <= 0:
        return target_weight

    if target_weight < previous_weight:
        # 降权:一次最多降到上一次的 25%
        return max(target_weight, previous_weight * (1 - MAX_CHANGE_RATE))

    # 恢复:一次最多提升到上一次的 25%
    return min(target_weight, previous_weight * (1 + MAX_CHANGE_RATE))

平滑不是没有代价的。它把「响应速度」换成了「稳定性」,这个交换必须是显式的选择:

场景平滑强度理由
信誉分档位降级滞后 3 天长期画像,不该因单次异常而崩塌
异常系数指数移动平均,α=0.3\alpha = 0.3需要连续几帧确认,但也要能抓住持续作弊
权重恢复单次最多提升 25%误判解除后立刻恢复等于没拦截住
严重作弊(分数 0.9 以上)不平滑,直接归零明确的作弊行为不能等

最后一条是关键:平滑只适用于「不确定」的判定,不适用于「确定」的判定。分数 0.95 以上、规则明确命中的作弊行为,应该立即降权甚至归零;平滑机制是用来处理检测器本身的不确定性的,而不是用来拖延明确结论的。

5.2 权重调整的可解释性

确保权重调整过程可追踪、可解释:

「可解释」在这个场景里有一个非常具体的定义:当一个用户问「我明明点了赞,为什么这条内容没上榜」,系统要能用一句业务语言回答,并且能给出证据。

这要求权重调整的过程留下结构化的痕迹,而不是只留下一个最终分数。

解释记录至少要包含四个部分:

组成内容用途
输入快照基础权重、信誉分、时间系数、异常分数复现这次计算
中间量每个因子收敛前后的值说明是数据异常还是配置问题
决策路径命中了哪条规则、走了哪一档说明为什么是这个结果
最终结果最终权重、处置动作、配置版本关联到具体的一次操作
from dataclasses import dataclass, field
from datetime import datetime
from typing import Dict, List, Optional


@dataclass
class ExplanationRecord:
    """一次权重计算的完整解释记录。"""

    content_id: str
    user_id: str
    behavior_type: str
    occurred_at: datetime

    # 输入快照
    base_weight: float
    trust_score: float
    trust_factor: float
    time_factor: float
    anomaly_score: float
    anomaly_factor: float

    # 最终结果
    final_weight: float
    action: str

    # 决策路径
    matched_rules: List[str] = field(default_factory=list)
    config_version: str = ""
    notes: List[str] = field(default_factory=list)

    def to_text(self) -> str:
        """生成可直接展示给用户或客服的解释。"""
        parts = [
            "行为类型 " + self.behavior_type,
            "基础权重 " + format(self.base_weight, ".2f"),
            "信誉系数 " + format(self.trust_factor, ".2f")
            + "(信誉分 " + format(self.trust_score, ".1f") + ")",
            "时间系数 " + format(self.time_factor, ".2f"),
            "异常系数 " + format(self.anomaly_factor, ".2f")
            + "(异常分 " + format(self.anomaly_score, ".2f") + ")",
            "最终权重 " + format(self.final_weight, ".3f"),
        ]
        if self.matched_rules:
            parts.append("命中规则 " + "、".join(self.matched_rules))
        return ";".join(parts)


class WeightExplainer:
    """根据计算过程中的输入与中间量生成解释记录。"""

    def __init__(self, config_version: str):
        self.config_version = config_version

    def explain(
        self,
        content_id: str,
        user_id: str,
        behavior_type: str,
        occurred_at: datetime,
        base_weight: float,
        trust_score: float,
        trust_factor: float,
        time_factor: float,
        anomaly_score: float,
        anomaly_factor: float,
        matched_rules: Optional[List[str]] = None,
    ) -> ExplanationRecord:
        final_weight = base_weight * trust_factor * time_factor * anomaly_factor

        notes = []
        # 把每一处「非默认取值」都标注出来,让解释落到具体因子上
        if trust_factor < 1.0:
            notes.append("信誉分低于基准,行为权重已下调")
        if time_factor < 1.0:
            notes.append("行为间隔过短,疑似连续触发")
        if anomaly_factor <= 0.0:
            notes.append("异常分数达到判定阈值,本次互动不计入热度")

        return ExplanationRecord(
            content_id=content_id,
            user_id=user_id,
            behavior_type=behavior_type,
            occurred_at=occurred_at,
            base_weight=base_weight,
            trust_score=trust_score,
            trust_factor=trust_factor,
            time_factor=time_factor,
            anomaly_score=anomaly_score,
            anomaly_factor=anomaly_factor,
            final_weight=final_weight,
            action=self.action_of(final_weight),
            matched_rules=list(matched_rules or []),
            config_version=self.config_version,
            notes=notes,
        )

    def action_of(self, final_weight: float) -> str:
        """按最终权重给出处置说明。"""
        if final_weight <= 0:
            return "不计入热度"
        if final_weight < 0.5:
            return "大幅降权"
        if final_weight < 0.9:
            return "轻度降权"
        return "正常计入"

可解释性在工程上要满足的三条要求:

  1. 解释与计算必须同源。解释不能是另外一套逻辑重新算一遍——那样两者迟早会对不上。正确做法是在计算的同一条路径上把中间量带出来,上面的 WeightResult 保留 base、trust、time、anomaly 四个因子正是这个原因。
  2. 解释要落库,不能只打日志。日志会滚动、会被清理,用户申诉可能发生在几个月后。要能回答「三个月前那次投票为什么只算了 0.1 分」,就必须有持久化的记录。
  3. 解释要带配置版本。三个月前用的是哪一版权重和阈值,必须能从记录里读出来。否则权重调整和后续的其他变更会纠缠在一起,永远说不清。

分层的解释粒度:

使用者需要的解释示例
普通用户一句话说明结论「这次互动未计入热度,因为系统检测到该账号存在异常行为」
客服同学具体因子与数值「信誉系数 0.30、异常系数 0.20,最终权重 0.060」
审核同学命中的规则与证据「命中 vote_speed_limit:60 秒内 240 次投票」
数据分析完整记录与配置版本全量字段,用于事后归因

这四层可以用同一条记录渲染出不同详略的视图,不需要为每一层单独设计一套日志。

5.3 A/B 测试权重策略

权重参数很难靠推理确定取值,但也很容易「调完看一眼大盘没变化就上线」。A/B 测试是把这类决策从「拍脑袋」变成「可验证」的标准手段。

实验设计要点:

要素做法原因
分流单位用户级,不是请求级同一用户看到不同策略会造成体验割裂,也会污染指标
实验对象用户与内容的交集有些用户根本没有被曝光过的内容参与,无法比较
分组方式正交分层权重实验与排序实验可以并行,不必互相阻塞
实验时长至少覆盖一个完整的日周期存在明显的时段效应(早晚高峰的作弊行为量不同)
观察指标业务指标 + 反作弊指标同时看只看业务指标容易把「误伤」当成收益

对照组与实验组的典型设计:

分组权重策略
对照组静态权重,ftrustf_{trust}、ftimef_{time}、fanomalyf_{anomaly} 全部固定为 1.0
实验组 A仅启用信誉分调整
实验组 B仅启用异常检测调整
实验组 C两者同时启用,且信誉分阈值更严格

这样设计的好处是能回答「到底是哪一个因子带来了收益(或损失)」。如果只做「静态权重 vs 全动态权重」,一旦结果变差,无法定位是哪个因子的问题。

指标选择。反作弊类的实验,主指标和护栏指标要分开看:

类型指标期望方向
主指标榜单中真实内容的占比上升
主指标头部内容的互动转化率不显著下降
护栏指标正常用户的负反馈率不上升
护栏指标新用户与中腰部创作者的内容曝光占比不下降
护栏指标申诉量与申诉通过率申诉通过率不上升

护栏指标比主指标更重要。一个能显著提升「榜单真实内容占比」的策略,如果同时把正常用户的负反馈率抬高了,那它在业务上就是失败的。反作弊的目标是让作弊变难,而不是让正常用户更难参与。

分析时要特别注意的两个陷阱:

  1. 辛普森悖论。整体指标上升,但分用户群看可能都是下降的——通常是因为作弊流量在实验组和对照组中的分布不均。分析时必须至少按新老用户、内容类型分群看一遍。
  2. 长期效应被短期实验掩盖。信誉分需要时间积累才能拉开差异,实验跑三天看到的效果远小于稳定态效果。这不代表策略无效,但意味着实验时长要按「信誉分的收敛周期」来定,而不是按常规实验的一两天。

样本量的估算思路:主指标是比例指标时,按两比例检验估算所需样本量;样本量主要由「基线值、最小可检测差异、显著性水平、检验功效」四个参数决定。这里强调一点:最小可检测差异(MDE)必须事先声明,并且要明确它是业务上真正关心的幅度。如果为了在样本量不足的情况下得到显著结果,把 MDE 取得极小,得到的结论在业务上是没意义的。

from dataclasses import dataclass
from math import ceil, sqrt


@dataclass
class SampleSizeResult:
    per_group: int
    total: int
    mde: float
    power: float


def estimate_sample_size(
    baseline_rate: float,
    mde: float,
    alpha: float = 0.05,
    power: float = 0.8,
) -> SampleSizeResult:
    """估算两比例检验所需的样本量。

    baseline_rate: 对照组的主指标基线值
    mde: 最小可检测差异(绝对值,例如基线为 0.2 时传 0.02 表示 2 个百分点)
    alpha: 显著性水平
    power: 检验功效
    """
    p1 = baseline_rate
    p2 = baseline_rate + mde
    if not 0 < p2 < 1:
        raise ValueError("实验组比例必须在 0 和 1 之间")

    # 标准差合并近似
    pooled = (p1 + p2) / 2
    std_diff = sqrt(2 * pooled * (1 - pooled))

    # z 分数近似:常用取值 alpha=0.05 对应 1.96,power=0.8 对应 0.84
    z_alpha = 1.96
    z_beta = 0.84

    per_group = ceil(((z_alpha + z_beta) * std_diff / mde) ** 2)
    return SampleSizeResult(
        per_group=per_group,
        total=per_group * 2,
        mde=mde,
        power=power,
    )

上线节奏与回滚:

  • 从小流量开始。先放 1% 流量,重点观察护栏指标和系统开销,而不是主指标。这个阶段的主要目的是发现工程问题。
  • 分阶段放量。每一步放量后观察一个完整周期,确认没有护栏指标恶化再继续。
  • 回滚开关必须是配置级的。权重参数、异常阈值、信誉分档位都要能通过配置中心即时调整。发版回滚在对抗场景下太慢了。
  • 保留对照组。即使全量上线,也建议保留 1% 到 5% 的对照组长期运行,用来持续观察策略在新环境下的表现,也给后续的策略迭代提供基线。

一个容易被忽略的细节:实验要记录「配置版本号」。上线三个月后再回看数据时,必须能说清某条数据是用哪一版权重算出来的。否则权重实验和后续的其他变更会纠缠在一起,无法归因。

六、案例分析

6.1 案例:识别刷赞行为

场景: 某内容在 10 分钟内获得 1000 个赞,但用户画像显示异常。

检测过程:

1. 频率检测:
   - 正常速率:10 赞/分钟
   - 当前速率:100 赞/分钟
   - Z-Score: 9.0 > 3.0 → 异常 ✓

2. 用户信誉检测:
   - 60% 用户信誉分 < 30
   - 40% 用户为新注册 (< 7 天)
   - 信誉异常 → 异常 ✓

3. 时间分布检测:
   - 互动时间集中在 3 个时间点
   - 熵值:0.2 < 0.5 → 异常 ✓

4. 权重调整:
   - 基础权重:1.0
   - 信誉调整:× 0.3
   - 异常调整:× 0.2
   - 最终权重:0.06 (降权 94%)

6.2 案例:优质内容识别

场景: 某专业内容互动量少但质量高。

权重提升策略:

1. 完播率高:95% → 权重 × 1.3
2. 收藏率高:30% → 权重 × 1.2
3. 专业用户互动多 → 权重 × 1.5
4. 举报率低:0.1% → 权重 × 1.1

综合权重提升:1.3 × 1.2 × 1.5 × 1.1 = 2.57 倍

七、总结

动态权重调整是反作弊系统的核心能力,通过以下关键机制实现:

机制作用实现难度
信誉分系统评估用户可信度中
时间衰减防止旧内容刷量低
异常检测识别可疑行为高
平滑处理避免排名剧烈波动中
可解释性便于审计和调试中

核心原则:

  1. 多维度信号:不依赖单一指标
  2. 实时响应:快速识别和响应异常
  3. 平滑过渡:避免权重突变
  4. 可追溯性:所有调整可审计
  5. 持续优化:基于数据迭代改进

通过合理的动态权重调整机制,可以在保证正常用户体验的同时,有效抑制作弊行为,维护排名系统的公平性和可信度。

发现内容有问题?

告诉我们哪里需要改进。