异常检测识别刷榜

在热门排行榜系统中,刷榜是最常见的作弊行为之一。异常检测是识别和防范刷榜行为的核心技术。本文详细介绍异常检测在防作弊系统中的应用。

目录

  1. 异常检测概述
  2. 常见刷榜行为模式
  3. 异常检测算法
  4. 系统架构设计
  5. 核心方案落地
  6. 监控与告警
  7. 最佳实践

异常检测概述

什么是异常检测

异常检测(Anomaly Detection)是指识别与正常模式显著不同的数据点或行为的技术。在排行榜系统中,异常检测用于识别:

  • 异常的投票行为
  • 异常的流量模式
  • 异常的用户行为
  • 异常的数据增长

为什么需要异常检测

正常用户行为          刷榜行为
    ↓                    ↓
分散、随机           集中、规律
时间分布均匀         时间密集爆发
设备多样化           设备集中
地域分散             地域集中

异常检测的目标

  1. 实时性:在刷榜行为发生时快速识别
  2. 准确性:降低误报率,避免影响正常用户
  3. 可扩展性:能够处理海量数据
  4. 自适应:能够适应新的作弊手段

常见刷榜行为模式

1. 时间集中型刷榜

在短时间内产生大量投票或互动:

时间轴:00:00 —— 01:00 —— 02:00 —— 03:00
正常:  █       █       █       █
刷榜:          ████████████████

特征识别:

  • 单位时间内请求量突增
  • 请求间隔过于规律
  • 请求时间集中在特定时段

2. 设备指纹型刷榜

使用有限设备进行大量操作:

指标正常用户刷榜用户
设备数/账号> 1.5< 1.1
IP 地址数分散集中
User-Agent多样单一/相似
屏幕分辨率多样集中

3. 行为模式型刷榜

行为轨迹不符合正常用户特征:

正常用户行为流:
首页 → 浏览 → 详情 → 投票 → 分享 → 退出

刷榜用户行为流:
投票接口 → 投票接口 → 投票接口 → ...

4. 关联网络型刷榜

多个账号之间存在关联关系:

账号集群:
┌─────────────────────────────────┐
│  账号 A ──┬── 账号 B            │
│           ├── 账号 C            │
│           ├── 账号 D            │
│           └── 账号 E            │
│           (相同设备/IP/行为)     │
└─────────────────────────────────┘

异常检测算法

1. 基于统计的方法

Z-Score 检测

Z-Score 衡量一个观测值偏离均值的程度,用标准差作为度量单位:

z=(x−μ)/σz = (x - \mu) / \sigma

其中 μ\mu 是样本均值,σ\sigma 是样本标准差。zz 的绝对值越大,说明这个观测值越”不像”正常数据。工程上通常以 zz 的绝对值是否超过阈值(常用 3)作为判定依据。

在实时场景里,均值和标准差不能直接对全量历史计算,否则旧数据的特征会淹没当前的变化。常用做法是维护滑动窗口统计量:

from collections import deque
from dataclasses import dataclass
from math import sqrt


@dataclass
class RollingStats:
    """滑动窗口的均值与标准差统计量。"""

    window: int
    values: deque

    def __post_init__(self):
        self.values = deque(maxlen=self.window)
        self._sum = 0.0
        self._sum_sq = 0.0

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

    @property
    def mean(self) -> float:
        if not self.values:
            return 0.0
        return self._sum / len(self.values)

    @property
    def stddev(self) -> float:
        n = len(self.values)
        if n < 2:
            return 0.0
        # 样本方差(除以 n-1),小样本下更稳健
        variance = (self._sum_sq - self._sum * self._sum / n) / (n - 1)
        return sqrt(variance) if variance > 0 else 0.0

    def z_score(self, value: float) -> float:
        sigma = self.stddev
        if sigma == 0:
            # 窗口内数据完全一致时无法计算标准差,视为异常
            return 0.0 if value == self.mean else float("inf")
        return (value - self.mean) / sigma


class ZScoreDetector:
    """基于 Z-Score 的异常检测器。"""

    def __init__(self, window: int = 100, threshold: float = 3.0):
        self.stats = RollingStats(window=window)
        self.threshold = threshold

    def check(self, value: float) -> bool:
        """判定一个观测值是否异常。异常时不更新统计量,避免污染基线。"""
        z = self.stats.z_score(value)
        is_anomaly = abs(z) > self.threshold
        if not is_anomaly:
            self.stats.add(value)
        return is_anomaly

Z-Score 的适用前提和边界:

  • 要求数据近似正态且方差稳定。刷榜行为本身就是一种非正态的尖峰,如果基线里已经混入了刷量数据,标准差会被撑大,异常反而检测不出来。
  • 对突发性全局增长不敏感。如果整个大盘同时出现异常流量,均值和标准差会一起抬升,Z-Score 可能完全看不出来。这时需要配合下面的移动平均检测,或者直接用绝对阈值。
  • 窗口长度决定灵敏度。窗口太短,标准差估计噪声大,容易误报;窗口太长,基线更新滞后,突发爆发被当成正常。实践中窗口按”能覆盖正常业务的周期”来选,例如按分钟粒度统计时,窗口取 30 到 60 分钟比较合适。
  • 异常值不要立刻写回基线。上面的实现里,判定为异常的样本不进入统计量,否则一次刷榜就会把基线抬起来,后续的刷榜都会被当成正常。

移动平均检测

移动平均检测关注的是当前值与近期趋势的偏离,而不是与整体分布的偏离。它对趋势性和波动性数据更稳健,是 Z-Score 的重要补充。

基本做法是维护一条指数移动平均线:

St=α⋅xt+(1−α)⋅St−1S_t = \alpha \cdot x_t + (1 - \alpha) \cdot S_{t-1}

其中 α\alpha 是平滑系数。α\alpha 越大,曲线对新数据反应越快但噪声越大;α\alpha 越小,曲线越平滑但对突发变化滞后。检测逻辑是:当当前观测值与移动平均值的偏差超过若干倍标准差时,判定为异常。

from collections import deque
from math import sqrt


class MovingAverageDetector:
    """基于指数移动平均 + 偏差阈值的异常检测器。"""

    def __init__(self, alpha: float = 0.2, window: int = 50, deviation: float = 3.0):
        if not 0 < alpha <= 1:
            raise ValueError("alpha 必须落在 (0, 1] 区间")
        self.alpha = alpha
        self.deviation = deviation
        self.history = deque(maxlen=window)
        self.smoothed = None

    def _deviation_of(self) -> float:
        """近期数据的标准差,作为偏差的度量单位。"""
        if len(self.history) < 2:
            return 0.0
        mean = sum(self.history) / len(self.history)
        variance = sum((v - mean) ** 2 for v in self.history) / (len(self.history) - 1)
        return sqrt(variance) if variance > 0 else 0.0

    def check(self, value: float) -> bool:
        """判定当前观测值是否偏离近期趋势。"""
        if self.smoothed is None:
            # 第一个样本只用于初始化基线
            self.smoothed = value
            self.history.append(value)
            return False

        deviation = self._deviation_of()
        is_anomaly = deviation > 0 and abs(value - self.smoothed) / deviation > self.deviation

        # 无论是否异常都更新基线:移动平均本来就是追踪趋势的
        self.smoothed = self.alpha * value + (1 - self.alpha) * self.smoothed
        self.history.append(value)
        return is_anomaly

两种方法的分工:

场景更适合的方法原因
单个账号的投票量突然暴增Z-Score需要判断该账号的行为偏离其自身历史水平
整个内容在一段时间内被集中刷移动平均需要判断趋势线的形状,而不是单点偏离
数据本身有周期性(每天同一时段高峰)移动平均移动平均能跟随趋势,Z-Score 会把周期性高峰误报
数据分布长尾、方差本身不稳定两者结合用移动平均定基线,用 Z-Score 做局部偏离判定

一个常见的改进是同时使用两者:移动平均负责跟踪基线,Z-Score 负责在该基线附近做局部异常判定。这样既能适应趋势,又不会因为整体分布变化而失去检测能力。

需要留意的是,移动平均检测的一个副作用是异常值会拉高基线。如果刷量持续时间很长,移动平均线会被一路抬高,检测就失效了。应对办法是在检测到异常时冻结基线更新(相当于把异常时段排除在基线之外),或者在更长周期上做季节性分解。

2. 基于机器学习的方法

Isolation Forest

Isolation Forest(孤立森林)是一种无监督异常检测算法,它的思路和统计方法完全不同:不建模正常数据的分布,而是直接「 isolating 」(隔离)异常点。

原理是:随机选取一个特征和一个切分点,把数据划分到两侧,递归重复直到每个点被单独隔离。异常点因为稀少,往往需要更少的切分次数就能被隔离出来。算法用路径长度作为异常分数的依据:

s(x)=2−E(h(x))/c(n)s(x) = 2^{-E(h(x)) / c(n)}

其中 E(h(x))E(h(x)) 是样本 xx 在随机树中的平均路径长度,c(n)c(n) 是把 nn 个样本完全隔离所需的平均路径长度修正项。当 s(x)s(x) 大于阈值时,该点被判定为异常。

from sklearn.ensemble import IsolationForest
import numpy as np


class IsolationForestDetector:
    """基于孤立森林的异常检测器。"""

    def __init__(self, contamination: float = 0.01, random_state: int = 42):
        self.model = IsolationForest(
            contamination=contamination,
            random_state=random_state,
            n_estimators=200,
            max_samples="auto",
        )
        self.fitted = False

    def fit(self, features: np.ndarray) -> None:
        """用历史正常数据训练模型。

        contamination 表示预期的异常比例,直接决定了判定阈值,
        取值应与业务对异常率的估计接近,取高会误报、取低会漏报。
        """
        self.model.fit(features)
        self.fitted = True

    def score(self, features: np.ndarray) -> np.ndarray:
        """返回异常分数,分数越接近 1 越可能是异常。"""
        if not self.fitted:
            raise RuntimeError("模型尚未训练")
        # decision_function 越大越正常,取负号后数值越大越异常
        return -self.model.decision_function(features)

    def predict(self, features: np.ndarray) -> np.ndarray:
        """返回布尔数组,True 表示异常。"""
        if not self.fitted:
            raise RuntimeError("模型尚未训练")
        return self.model.predict(features) == -1

特征怎么选,往往比模型本身更重要。孤立森林是基于随机轴划分的,特征之间的量纲差异会影响划分的有效性,因此所有特征必须先标准化。在刷榜检测的典型场景中,常用的特征组合是:

  • 单位时间内的互动次数
  • 参与互动的独立账号数
  • 互动账号的新老用户比例
  • 互动时间的分布熵
  • 参与设备的集中度

参数取舍:

参数含义取值影响
contamination预期异常比例直接决定阈值,取值偏高会显著增加误报
n_estimators树的数量越多越稳定,但训练和推理成本线性上升
max_samples每棵树采样数偏小会更快收敛,但也更容易把正常点误判为异常
random_state随机种子固定后才能保证结果可复现,便于排查问题

优点与局限:

  • 优点:不需要标注数据,能自动发现训练数据里没见过的异常模式,对多维特征之间的复杂关系有表达能力。
  • 局限:可解释性弱于统计方法和规则方法;结果依赖特征质量;训练数据如果已经被刷量污染,「异常」的定义就会被污染。
  • 成本:相比统计方法,模型推理开销大得多,不适合放在单条互动事件的实时路径上,通常用在离线批处理或准实时的用户画像评分上。

在真实系统里,孤立森林一般不单独使用,而是作为综合异常评分中的一个信号,与统计指标、规则命中结果一起参与最终判定。

3. 基于规则的方法

规则方法是所有检测手段中最朴素、但也是最不可替代的一类。它把已知的作弊模式显式写成可执行的判断,优点是行为可预测、可解释、可运营,缺点是只能发现已知模式。

规则的典型形态是「条件 + 阈值 + 动作」:

规则示例:
  - 规则 ID: vote_speed_limit
    描述: 单账号单位时间内投票次数超过阈值
    条件: votes_per_minute > 20
    动作: 降权(该账号本轮互动权重置 0)
    级别: 高

规则适合表达这些判断:

  • 硬阈值类:单账号投票速率上限、单 IP 每分钟请求数上限、单设备关联账号数上限。
  • 聚集度类:短时间内参与互动的账号中,来自同一设备或同一网段的比例超过阈值。
  • 模式类:行为序列中缺少正常用户应有的环节(例如只有投票接口调用,没有任何内容浏览记录)。
  • 交叉类:账号注册时间过短,却已经在多个内容上产生互动。

用声明式配置描述规则,可以让规则本身成为配置而不是代码:

rules:
  - id: vote_speed_limit
    description: 单账号单位时间内投票次数超过阈值
    scope: user
    metric: votes_per_minute
    condition: "value > 20"
    action: ZERO_WEIGHT
    severity: HIGH
    enabled: true

  - id: device_cluster_ratio
    description: 参与互动的账号中来自同一设备的比例过高
    scope: content
    metric: device_cluster_ratio
    condition: "value > 0.7"
    action: DOWN_SCORE
    severity: MEDIUM
    enabled: true

  - id: missing_browse_step
    description: 账号只调用投票接口,没有内容浏览记录
    scope: session
    metric: browse_to_vote_ratio
    condition: "value < 0.01"
    action: ZERO_WEIGHT
    severity: MEDIUM
    enabled: true

规则引擎的评估顺序很重要。推荐按「成本从低到高、置信度从高到低」的顺序执行:

顺序规则类型成本置信度命中后的动作
1单键硬阈值极低高直接零权重
2跨键聚合(设备、IP 聚集度)低中高降权
3序列与模式匹配中中降权或转人工审核
4统计与模型判定高视情况综合扣分

先跑便宜的规则,可以在最常见的作弊场景上用极小的开销拦下大部分请求,把昂贵的统计与模型计算留给存疑的样本。

规则方法最大的工程挑战是维护。规则数量增长后,会出现规则之间互相覆盖、阈值之间互相矛盾的问题。建议:

  • 给规则编号和责任人,任何一次命中都能追溯到具体规则和当时的配置版本。
  • 对规则做回归测试,用一段固定的标注样本跑全部规则,确保改动不会让已有规则失效。
  • 统计每条规则的命中率和误报率,长期零命中的规则应当下线,长期高误报的规则应当调整。
  • 设置灰度和快速下线开关,规则必须能在不发版的情况下停用。

在整体检测体系中,规则、统计、机器学习三者的定位是互补的:规则负责确定性的已知模式,统计负责单指标的偏离,机器学习负责多维组合的未知模式。三者给出的结论汇总进统一的异常评分系统,由它决定最终处置动作。

4. 基于图的方法

前面三种方法都只看单个账号的行为特征。但真实的刷榜往往是有组织的:一批账号共用同一批设备、同一批出口 IP,彼此之间还互相点赞。单看每一个账号都很「正常」,只有把它们放进关系网络里,才能看出这是一伙人。图方法做的就是这件事——把实体和关系建成图,用图上的结构指标识别异常群体。

三种典型建法:

图模型节点边擅长发现
账号-设备二部图账号、设备账号登录过该设备设备农场、账号共享
账号-账号相似图账号行为轨迹高度相似批量注册的小号群
内容-互动图内容、账号账号互动过该内容内容操纵团伙

二部图是最常用的一种,因为它的边来自登录日志这类客观事实,不需要靠相似度去猜。构建时只需要把「账号登录过设备」这一条关系写入图,剩下的判定交给连通分量和聚集度。

from collections import defaultdict


class AccountDeviceGraph:
    """账号与设备的二部图。

    刷榜团伙的特征是:大量账号聚集在很少的设备上。
    连通分量给出团伙的规模,密度给出团伙的紧密程度,
    两个指标同时超阈值,才判定为可疑群体。
    """

    def __init__(self, min_component_size: int = 5, min_density: float = 0.6):
        self.min_component_size = min_component_size
        self.min_density = min_density
        self.account_devices = defaultdict(set)

    def add(self, account_id: str, device_id: str) -> None:
        self.account_devices[account_id].add(device_id)

    def density(self, accounts: list) -> float:
        """二部图密度 = 边数 / (账号数 × 设备数)。

        完全共用同一批设备时密度接近 1;
        正常用户之间的设备共享非常稀疏,密度接近 0。
        """
        devices = set()
        edges = 0
        for account_id in accounts:
            used = self.account_devices.get(account_id, set())
            devices |= used
            edges += len(used)
        if not accounts or not devices:
            return 0.0
        return edges / (len(accounts) * len(devices))

    def suspicious_groups(self) -> list:
        """找出可疑团伙:规模够大且设备聚集度够高。

        用并查集求连通分量。节点统一加前缀,
        这样账号节点和设备节点可以放进同一张图,
        也能在最后按前缀拆分回来。
        """
        parent = {}

        def find(node: str) -> str:
            parent.setdefault(node, node)
            root = node
            while parent[root] != root:
                root = parent[root]
            while parent[node] != root:
                parent[node], node = root, parent[node]
            return root

        for account_id, devices in self.account_devices.items():
            account_node = "a:" + account_id
            find(account_node)
            for device_id in devices:
                device_node = "d:" + device_id
                find(device_node)
                ra = find(account_node)
                rd = find(device_node)
                if ra != rd:
                    parent[ra] = rd

        groups = defaultdict(set)
        for node in list(parent):
            groups[find(node)].add(node)

        result = []
        for members in groups.values():
            accounts = sorted(node[2:] for node in members if node.startswith("a:"))
            if len(accounts) < self.min_component_size:
                continue
            if self.density(accounts) < self.min_density:
                continue
            result.append(accounts)
        return result

图上的几个关键指标:

指标计算方式异常信号
连通分量规模二部图中互相连通的账号数量突然出现规模 20 以上的分量
设备聚集度边数 / (账号数 × 设备数)明显高于全站均值
设备度数集中度设备上关联账号数的方差少数设备关联了绝大多数账号
社群模块度Louvain 算法求得的模块度出现模块度很高的独立社群

优点与局限:

  • 优点:单账号特征再正常,成团出现时结构上依然会露馅;不需要标注数据;对新型作弊手法有一定泛化能力。
  • 局限:图构建依赖登录日志这类数据,日志不全时图就是残缺的,残缺的图会漏检;社区发现类算法(Louvain、标签传播)计算开销大,通常只能离线跑,放不进单条事件的实时路径。
  • 定位:图分析适合作为离线或准实时的团伙识别手段,产出的团伙名单再回灌到实时规则里,而不是直接在线判定。

系统架构设计

整体架构

┌─────────────────────────────────────────────────────────────┐
│                      数据采集层                              │
├─────────────┬─────────────┬─────────────┬─────────────────┤
│  投票日志   │  设备指纹   │  网络请求   │   用户行为       │
└──────┬──────┴──────┬──────┴──────┬──────┴────────┬────────┘
       │             │             │               │
       ▼             ▼             ▼               ▼
┌─────────────────────────────────────────────────────────────┐
│                      实时计算层 (Flink)                      │
├─────────────┬─────────────┬─────────────┬─────────────────┤
│  特征提取   │  窗口聚合   │  实时评分   │   异常标记       │
└──────┬──────┴──────┬──────┴──────┬──────┴────────┬────────┘
       │             │             │               │
       ▼             ▼             ▼               ▼
┌─────────────────────────────────────────────────────────────┐
│                      检测引擎层                              │
├─────────────┬─────────────┬─────────────┬─────────────────┤
│  规则引擎   │  统计检测   │  机器学习   │   图分析         │
└──────┬──────┴──────┬──────┴──────┬──────┴────────┬────────┘
       │             │             │               │
       ▼             ▼             ▼               ▼
┌─────────────────────────────────────────────────────────────┐
│                      决策执行层                              │
├─────────────┬─────────────┬─────────────┬─────────────────┤
│  限流      │  封禁       │  降权       │   人工审核       │
└─────────────┴─────────────┴─────────────┴─────────────────┘

数据流设计

整体架构画的是「有哪些模块」,数据流设计要回答的是「一条行为从产生到变成一个排名,要流经哪些环节,每个环节的延迟预算是多少」。这条链路横跨两个世界:判定链路(可以慢,但必须准)和请求链路(必须快,只做判断)。

行为事件
   │
   ▼
┌────────────────────────────┐
│ 采集层:Kafka 埋点流         │  分区键 content_id
└──────────────┬─────────────┘
               ▼
┌────────────────────────────┐
│ 计算层:Flink 实时作业       │  5 分钟滑动窗口 / 30 秒步长
│  特征提取 → 窗口聚合         │
└──────────────┬─────────────┘
               ▼
┌────────────────────────────┐
│ 检测层:规则 / 统计 / 图      │  每条事件一次判定
└──────────────┬─────────────┘
               ▼
┌────────────────────────────┐
│ 决策层:异常评分 → 处置单     │  分数阈值决定动作力度
└──────────────┬─────────────┘
               ▼
┌────────────────────────────┐
│ 执行层:拦截 / 降权 / 封禁     │
└────────────────────────────┘

各环节的延迟预算:

环节输入输出关键指标延迟预算
采集客户端行为事件Kafka 消息接入成功率、消费延迟100 毫秒内入队
计算Kafka 消息特征与窗口聚合结果Checkpoint 耗时、状态大小秒级
检测特征与事件异常分数规则命中量、判定 P995 毫秒内
决策异常分数处置单处置单生成速率1 毫秒内
执行处置单拦截、降权、封禁执行失败率10 毫秒内
在线读取Redis 中的处置结果放行或拦截读取 P991 毫秒内

在线与离线的边界是最需要说清楚的一点。检测本身跑在异步链路上:用户的一次投票可能在几百毫秒后才被判定为作弊,而那时这次投票早已计入热度。但处置必须同步生效——不能等异步链路算完才去拦截下一个请求。

因此处置结果必须落到一个在线可读的存储里:

判定链路(异步):Flink → 检测引擎 → 处置单 → Redis 处置结果集合
请求链路(同步):用户请求 → 读取处置结果集合 → 放行或拦截

这样就有了两套时间标准:请求链路只关心「这个账号当前是否已被判定为作弊」,读的是集合的当前状态,不必等这一次打分;打分链路负责持续更新这个状态。一个带 TTL 的 Redis Set 就够用:

# 处置结果集合:成员是账号 ID,TTL 取最轻一档处置的持续时间
SADD anomaly:blocked:user 10086
EXPIRE anomaly:blocked:user 86400

# 请求链路只做一次 O(1) 判断
SISMEMBER anomaly:blocked:user 10086

流控是这个架构最容易出问题的地方。Flink 出现背压时,处置结果的产生速度会下降,但请求链路读到的仍是上一份状态。处理方式是:状态缺失时按放行处理,同时告警。反作弊链路是增强手段而不是主链路,让它拖垮整个业务是不可接受的。

数据一致性也要有约定。实时链路和离线链路都做检测时,两边的规则版本必须一致,否则会出现「实时判定为正常、离线判定为作弊」的矛盾。规则版本号要写进处置单,排查时才能说清当时用的是哪一版规则。


核心方案落地

特征工程

异常检测的效果,取决于喂给它的特征好不好。好的特征有三个共性:在异常样本和正常样本之间有区分度、能稳定地实时计算出来、不会因为业务口径调整而频繁失效。

按检测维度,特征可以分成四类:

维度特征举例区分能力计算成本
时间互动速率、请求间隔方差、互动时间分布熵、夜间互动占比识别集中爆发与机器节奏低
设备设备数/账号数、设备型号集中度、模拟器标识识别设备农场低
账号注册时长、历史互动多样性、账号间行为相似度识别批量注册的小号中
关系账号-设备二部图连通性、同 IP 账号占比识别关联账号群高

时间维度是性价比最高的一类,因为计算几乎不需要额外数据。实现上通常先做一个时间分桶,把明细事件聚合成特征:

from collections import Counter, defaultdict
from dataclasses import dataclass, field
from datetime import datetime
from math import log


@dataclass
class BucketFeatures:
    """一个时间桶内的特征。"""

    bucket_start: datetime
    event_count: int = 0
    unique_users: set = field(default_factory=set)
    unique_devices: set = field(default_factory=set)
    timestamps: list = field(default_factory=list)

    @property
    def events_per_user(self) -> float:
        if not self.unique_users:
            return 0.0
        return self.event_count / len(self.unique_users)

    @property
    def device_user_ratio(self) -> float:
        """设备数与账号数的比值,越接近 1 说明账号高度集中。"""
        if not self.unique_users:
            return 0.0
        return len(self.unique_devices) / len(self.unique_users)

    @property
    def time_entropy(self) -> float:
        """互动时间的分布熵。

        把时间桶再切成若干小区间,统计互动在小区间上的分布,
        熵越低说明互动越集中在极短的时间范围内,符合刷量特征。
        """
        if not self.timestamps:
            return 0.0
        if self.bucket_start is None:
            return 0.0
        base = self.bucket_start.timestamp()
        slots = Counter(int((ts - base) // 10) for ts in self.timestamps)
        total = sum(slots.values())
        if total <= 1:
            return 0.0
        entropy = 0.0
        for count in slots.values():
            p = count / total
            entropy -= p * log(p)
        # 归一化到 0 到 1,便于与其他特征拼接
        max_entropy = log(len(slots)) if len(slots) > 1 else 1.0
        return entropy / max_entropy if max_entropy > 0 else 0.0

    @property
    def interval_variance(self) -> float:
        """相邻互动间隔的方差,机器行为的间隔往往过于规整,方差很小。"""
        if len(self.timestamps) < 3:
            return 0.0
        ordered = sorted(self.timestamps)
        intervals = [ordered[i + 1] - ordered[i] for i in range(len(ordered) - 1)]
        mean = sum(intervals) / len(intervals)
        if mean == 0:
            return 0.0
        variance = sum((v - mean) ** 2 for v in intervals) / len(intervals)
        return variance / (mean * mean)


def extract_features(events: list, bucket_seconds: int = 60) -> list:
    """从原始事件流中提取时间桶特征。

    events 中每个元素包含 user_id、device_id、timestamp 三个字段。
    """
    buckets = defaultdict(lambda: BucketFeatures(bucket_start=None))
    for event in events:
        slot = int(event["timestamp"] // bucket_seconds) * bucket_seconds
        bucket = buckets[slot]
        if bucket.bucket_start is None:
            bucket.bucket_start = datetime.fromtimestamp(slot)
        bucket.event_count += 1
        bucket.unique_users.add(event["user_id"])
        bucket.unique_devices.add(event["device_id"])
        bucket.timestamps.append(event["timestamp"])

    features = []
    for slot in sorted(buckets):
        bucket = buckets[slot]
        features.append({
            "bucket_start": slot,
            "event_count": bucket.event_count,
            "events_per_user": bucket.events_per_user,
            "device_user_ratio": bucket.device_user_ratio,
            "time_entropy": bucket.time_entropy,
            "interval_variance": bucket.interval_variance,
        })
    return features

特征工程上有几条实践原则值得强调:

  • 先看区分度,再上线。候选特征可以先在离线数据上算一遍,看正常样本与已知作弊样本的分布差异。区分度不明显的特征,放进模型只是增加计算成本。
  • 特征要能解释。审核同学需要能看懂”因为这个账号在 10 分钟内产生了 80 次投票且全部来自同一设备”这样的理由。过于抽象的特征即使有效,也很难支撑申诉和纠纷处理。
  • 警惕特征泄漏。用「该账号最终是否被封禁」这类结果反推的特征,离线效果会非常好,线上却完全无效——因为封禁结果在打分时刻还不存在。
  • 控制特征总量。特征越多,模型越容易过拟合到训练期的特定作弊模式;同时每增加一个特征,就增加一份计算和存储成本。建议从十几条核心特征起步,并定期做特征筛选。

异常评分系统

前面几节产出的都是离散的判定:Z-Score 说”这条超了阈值”,规则说”命中了某条规则”,孤立森林给出一个异常分数。但处置动作需要的是一个可以统一比较的量,否则很难回答”这个账号该不该封”这种问题。

异常评分系统把这些信号汇总成一个 0 到 1 的分数:

AnomalyScore=∑iwi⋅si\text{AnomalyScore} = \sum_{i} w_i \cdot s_i

其中 sis_i 是第 ii 个信号归一化后的异常强度(同样落在 0 到 1),wiw_i 是该信号的权重。所有权重加起来为 1,分数越高代表越可疑。

from dataclasses import dataclass
from enum import Enum


class Action(Enum):
    """处置动作,按处置力度递增排列。"""
    NORMAL = "normal"        # 正常,不做任何处理
    OBSERVE = "observe"      # 观察:记录并继续跟踪
    DOWN_SCORE = "down_score"  # 降权:本次互动权重打折
    ZERO_WEIGHT = "zero"     # 零权重:本次互动不计入热度
    BLOCK = "block"          # 拦截:拒绝该请求


@dataclass
class Signal:
    """一路检测信号。"""
    name: str
    weight: float
    value: float


class AnomalyScorer:
    """异常评分与处置决策。"""

    def __init__(self, thresholds: dict = None):
        # 分数区间与处置动作的对应关系,阈值需要按线上数据校准
        self.thresholds = thresholds or {
            0.00: Action.NORMAL,
            0.35: Action.OBSERVE,
            0.55: Action.DOWN_SCORE,
            0.75: Action.ZERO_WEIGHT,
            0.90: Action.BLOCK,
        }

    def score(self, signals: list) -> float:
        """把多路信号合成为最终异常分数。"""
        total_weight = sum(signal.weight for signal in signals)
        if total_weight <= 0:
            return 0.0
        total = 0.0
        for signal in signals:
            # 单路信号的值必须落在 0 到 1,超出部分做截断
            value = max(0.0, min(1.0, signal.value))
            total += signal.weight * value
        return total / total_weight

    def decide(self, score: float) -> Action:
        """按分数决定处置动作。"""
        action = Action.NORMAL
        for threshold, candidate in sorted(self.thresholds.items()):
            if score >= threshold:
                action = candidate
        return action

    def evaluate(self, signals: list) -> tuple:
        """一次性返回分数与处置动作。"""
        score = self.score(signals)
        return score, self.decide(score)

信号如何归一化是这套系统里最关键的一步。不同信号的性质完全不同,不能直接相加:

信号原始输出归一化方式
Z-Score可正可负的浮点数用 min⁡(∣z∣/zmax,1)\min(\lvert z \rvert / z_{max}, 1) 压缩到 0 到 1
规则命中是否命中、命中几条命中一条记 1,多条按对数压缩避免一次爆量
孤立森林异常分数,接近 1 为异常直接线性映射到 0 到 1
时间分布熵0 到 1,越低越可疑用 1 减去熵值
设备聚集度0 到 1,越高越可疑直接使用

权重怎么定:初期可以按经验给出,之后用历史标注数据拟合(例如逻辑回归),但要保留人工干预的通道——当业务发现某类信号突然大面积误报时,需要能单独把它的权重调低,而不用重新训练模型。

阈值必须校准。上表里的阈值是示意值,真实取值要结合两件事确定:

  • 误报的业务承受度。误伤一个正常用户造成的损失,与放过一个刷榜账号造成的损失,往往不对称。绝大多数情况下宁可漏放也不要误伤。
  • 处置动作的成本。OBSERVE 几乎没有成本,BLOCK 会直接影响用户,因此越重的动作越应该配越高的阈值。

评分系统本身也要被监控:

  • 分布监控:观察异常分数的整体分布。如果高分段的占比突然上升,可能是出现了新的作弊手法,也可能是某条规则失效了。
  • 处置量监控:各处置动作的日均量。某个动作的数量突变,通常比单个分数更能说明问题。
  • 申诉回溯:对被 BLOCK 的账号抽样人工复核,统计误判比例,必要时回调阈值。

最后,评分结果应该全链路留痕:命中了哪些信号、各信号的原始值、最终分数、触发的动作、使用的配置版本。缺少这些信息,运营排查和用户申诉都无从下手。

自动处置系统

检测引擎的最终产物是一个异常分数,但分数本身不能直接驱动动作——把「可疑」翻译成「封号」需要一套明确的分级规则,否则一次误报就会变成一次真实的用户损失。

处置动作按力度递增分为五级,动作越重,触发的分数阈值越高:

动作触发分数生效方式可逆性用户感知
观察0.35 到 0.55记录并继续跟踪自动恢复无
降权0.55 到 0.75本次互动权重打折下一个窗口自然恢复无
零权重0.75 到 0.90互动不计入热度下一个窗口自然恢复轻微
拦截0.90 到 0.97拒绝该次请求需人工解除明显
封禁0.97 以上账号进入黑名单需人工解除严重

这几档阈值与前文「异常评分系统」中的阈值表一致,两个地方必须同步,否则会出现分数算到 0.8 却执行了拦截的矛盾。

import java.time.Instant;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 自动处置系统:把异常分数翻译成处置动作并执行。
 *
 * 三条设计纪律:
 * 1. 判定与执行分离,处置单先落库再执行,便于回溯和重放;
 * 2. 每个动作都有唯一处置单号,重复触发不会重复执行;
 * 3. 不可逆动作(封禁)只进人工复核队列,系统不自动执行。
 */
public class AutoDispositionSystem {

    /** 处置动作,按力度递增排列。 */
    public enum Action {
        /** 观察:记录并继续跟踪。 */
        OBSERVE,
        /** 降权:本次互动权重打折。 */
        DOWN_SCORE,
        /** 零权重:本次互动不计入热度。 */
        ZERO_WEIGHT,
        /** 拦截:拒绝该次请求。 */
        BLOCK,
        /** 封禁:账号进入黑名单。 */
        BAN
    }

    /** 处置单。 */
    public record Disposition(
            String orderId,
            String userId,
            Action action,
            double anomalyScore,
            Instant createdAt,
            String evidence
    ) {}

    /** 分数阈值与动作的对应关系,按分数降序排列。 */
    private static final Map<Double, Action> SCORE_BANDS = new LinkedHashMap<>();

    static {
        SCORE_BANDS.put(0.97, Action.BAN);
        SCORE_BANDS.put(0.90, Action.BLOCK);
        SCORE_BANDS.put(0.75, Action.ZERO_WEIGHT);
        SCORE_BANDS.put(0.55, Action.DOWN_SCORE);
        SCORE_BANDS.put(0.35, Action.OBSERVE);
    }

    /** 处置执行器:把动作交给对应的执行方(封禁交给黑名单服务,降权交给权重引擎)。 */
    public interface DispositionExecutor {
        /**
         * 执行处置。
         *
         * @param action      处置动作
         * @param userId      被处置的账号
         * @param disposition 处置单,执行方据此留痕
         */
        void execute(Action action, String userId, Disposition disposition);
    }

    /** 人工复核队列。 */
    public interface ReviewQueue {
        void submit(Disposition disposition, String reason);
    }

    /** 已处理的处置单,保证幂等。 */
    private final ConcurrentHashMap<String, Disposition> processed = new ConcurrentHashMap<>();

    private final DispositionExecutor executor;
    private final ReviewQueue reviewQueue;

    public AutoDispositionSystem(DispositionExecutor executor, ReviewQueue reviewQueue) {
        this.executor = executor;
        this.reviewQueue = reviewQueue;
    }

    /**
     * 根据异常分数决定处置动作。
     */
    public Action decide(double anomalyScore) {
        double score = Math.max(0.0, Math.min(1.0, anomalyScore));
        Action action = Action.OBSERVE;
        for (Map.Entry<Double, Action> band : SCORE_BANDS.entrySet()) {
            if (score >= band.getKey()) {
                action = band.getValue();
            }
        }
        return action;
    }

    /**
     * 生成并执行处置单。
     *
     * 处置单号由账号、动作和证据共同决定,重复触发时命中已有单据,
     * 不会重复执行写入。
     */
    public Disposition handle(String userId, double anomalyScore, String evidence) {
        Action action = decide(anomalyScore);
        String orderId = userId + "|" + action.name() + "|" + Integer.toHexString(evidence.hashCode());

        Disposition existing = processed.get(orderId);
        if (existing != null) {
            return existing;
        }

        Disposition disposition =
                new Disposition(orderId, userId, action, anomalyScore, Instant.now(), evidence);
        processed.putIfAbsent(orderId, disposition);

        if (action == Action.BAN) {
            // 封禁不可逆,只进人工复核队列,由审核同学确认后执行
            reviewQueue.submit(disposition, "异常分数超过封禁阈值");
        } else {
            executor.execute(action, userId, disposition);
        }
        return disposition;
    }

    /**
     * 解除处置。只有人工确认后才调用。
     */
    public void revoke(String orderId, String operator) {
        Disposition disposition = processed.get(orderId);
        if (disposition == null) {
            throw new IllegalArgumentException("处置单不存在: " + orderId);
        }
        processed.remove(orderId);
        executor.execute(Action.OBSERVE, disposition.userId(), disposition);
    }
}

处置执行的三条纪律:

  1. 不可逆动作必须人工确认。封禁会直接影响真实用户,自动执行的前提是误报率极低。分数最高的那一档只进人工复核队列,而不是直接执行。
  2. 处置单必须可追溯。每一张处置单都要记录账号、动作、触发的分数、证据和规则版本。没有这些,用户申诉时无法解释「为什么这次投票只算了 0.1 分」,运营也定位不到是哪条规则起了作用。
  3. 处置必须有明确的解除路径。误封之后能改回来,比误封率本身更重要。解除动作同样要生成记录,不能悄悄地把一条处置单从表里抹掉。

动作与执行方的对应关系:

动作执行方生效范围副作用
观察审计日志无只有监控指标变化
降权权重引擎当前互动分数偏低,需要在看板上看出来
零权重权重引擎当前互动同上,但不计入任何统计
拦截网关当前请求用户会收到明确的提示
封禁黑名单服务该账号账号功能受限,直到人工解除

上线节奏同样要分阶段。新规则上线时先用「只观察不执行」的模式跑一段时间,观察疑似作弊的规模和准确率;确认无误报后再逐档放开执行力度。直接从「观察」跳到「拦截」的中间档位,是最容易出事故的做法。


监控与告警

核心指标监控

配置要点

  • 配置表达的是环境差异和运行参数,不是业务规则本身。
  • 队列、缓存、存储和服务参数决定系统在高峰期的缓冲能力。

告警规则

配置要点

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

监控大盘

配置要点

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

最佳实践

1. 分层防御

┌─────────────────────────────────────┐
│           客户端防护层               │
│  - 设备指纹  - 行为验证  - 限流      │
└─────────────────┬───────────────────┘
                  │
┌─────────────────▼───────────────────┐
│           网关防护层                 │
│  - IP 限流  - 频率控制  - 黑名单     │
└─────────────────┬───────────────────┘
                  │
┌─────────────────▼───────────────────┐
│           业务防护层                 │
│  - 异常检测  - 规则引擎  - 机器学习  │
└─────────────────┬───────────────────┘
                  │
┌─────────────────▼───────────────────┐
│           数据防护层                 │
│  - 数据校验  - 审计日志  - 追溯分析  │
└─────────────────────────────────────┘

2. 持续优化

  • 定期更新规则:根据新发现的作弊手段更新检测规则
  • 模型迭代:定期重新训练机器学习模型
  • 误报分析:分析误报案例,优化检测阈值
  • 红队测试:定期进行对抗测试,发现系统漏洞

3. 灰度发布

新规则/模型发布流程:

1. 离线验证 → 2. 小流量实验 → 3. 逐步放量 → 4. 全量发布
     ↓              ↓              ↓              ↓
  历史数据       1% 流量        10% → 50%       100% 流量
  准确率评估     误报率监控     效果对比        全面监控

4. 人机协同

场景自动处理人工审核
低风险异常✅❌
中风险异常✅ + 记录抽样
高风险异常临时限制✅
严重异常立即封禁✅ + 追溯

5. 合规与隐私

  • 数据最小化:只收集必要的检测数据
  • 数据脱敏:存储时进行匿名化处理
  • 用户告知:在隐私政策中说明检测机制
  • 申诉机制:提供误封申诉渠道

总结

异常检测是防作弊系统的核心技术,需要:

  1. 多维度特征:结合时间、设备、行为等多维度数据
  2. 多层次检测:规则、统计、机器学习相结合
  3. 实时响应:快速识别并处置异常行为
  4. 持续优化:根据对抗结果不断迭代改进

通过建立完善的异常检测体系,可以有效识别和防范刷榜行为,保障排行榜的公平性和可信度。

发现内容有问题?

告诉我们哪里需要改进。