异常检测识别刷榜
在热门排行榜系统中,刷榜是最常见的作弊行为之一。异常检测是识别和防范刷榜行为的核心技术。本文详细介绍异常检测在防作弊系统中的应用。
什么是异常检测
异常检测(Anomaly Detection)是指识别与正常模式显著不同的数据点或行为的技术。在排行榜系统中,异常检测用于识别:
- 异常的投票行为
- 异常的流量模式
- 异常的用户行为
- 异常的数据增长
为什么需要异常检测
正常用户行为 刷榜行为
↓ ↓
分散、随机 集中、规律
时间分布均匀 时间密集爆发
设备多样化 设备集中
地域分散 地域集中
异常检测的目标
- 实时性:在刷榜行为发生时快速识别
- 准确性:降低误报率,避免影响正常用户
- 可扩展性:能够处理海量数据
- 自适应:能够适应新的作弊手段
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 衡量一个观测值偏离均值的程度,用标准差作为度量单位:
其中 是样本均值, 是样本标准差。 的绝对值越大,说明这个观测值越”不像”正常数据。工程上通常以 的绝对值是否超过阈值(常用 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 的重要补充。
基本做法是维护一条指数移动平均线:
其中 是平滑系数。 越大,曲线对新数据反应越快但噪声越大; 越小,曲线越平滑但对突发变化滞后。检测逻辑是:当当前观测值与移动平均值的偏差超过若干倍标准差时,判定为异常。
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 」(隔离)异常点。
原理是:随机选取一个特征和一个切分点,把数据划分到两侧,递归重复直到每个点被单独隔离。异常点因为稀少,往往需要更少的切分次数就能被隔离出来。算法用路径长度作为异常分数的依据:
其中 是样本 在随机树中的平均路径长度, 是把 个样本完全隔离所需的平均路径长度修正项。当 大于阈值时,该点被判定为异常。
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 耗时、状态大小 | 秒级 |
| 检测 | 特征与事件 | 异常分数 | 规则命中量、判定 P99 | 5 毫秒内 |
| 决策 | 异常分数 | 处置单 | 处置单生成速率 | 1 毫秒内 |
| 执行 | 处置单 | 拦截、降权、封禁 | 执行失败率 | 10 毫秒内 |
| 在线读取 | Redis 中的处置结果 | 放行或拦截 | 读取 P99 | 1 毫秒内 |
在线与离线的边界是最需要说清楚的一点。检测本身跑在异步链路上:用户的一次投票可能在几百毫秒后才被判定为作弊,而那时这次投票早已计入热度。但处置必须同步生效——不能等异步链路算完才去拦截下一个请求。
因此处置结果必须落到一个在线可读的存储里:
判定链路(异步):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 的分数:
其中 是第 个信号归一化后的异常强度(同样落在 0 到 1), 是该信号的权重。所有权重加起来为 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 | 可正可负的浮点数 | 用 压缩到 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);
}
}
处置执行的三条纪律:
- 不可逆动作必须人工确认。封禁会直接影响真实用户,自动执行的前提是误报率极低。分数最高的那一档只进人工复核队列,而不是直接执行。
- 处置单必须可追溯。每一张处置单都要记录账号、动作、触发的分数、证据和规则版本。没有这些,用户申诉时无法解释「为什么这次投票只算了 0.1 分」,运营也定位不到是哪条规则起了作用。
- 处置必须有明确的解除路径。误封之后能改回来,比误封率本身更重要。解除动作同样要生成记录,不能悄悄地把一条处置单从表里抹掉。
动作与执行方的对应关系:
| 动作 | 执行方 | 生效范围 | 副作用 |
|---|---|---|---|
| 观察 | 审计日志 | 无 | 只有监控指标变化 |
| 降权 | 权重引擎 | 当前互动 | 分数偏低,需要在看板上看出来 |
| 零权重 | 权重引擎 | 当前互动 | 同上,但不计入任何统计 |
| 拦截 | 网关 | 当前请求 | 用户会收到明确的提示 |
| 封禁 | 黑名单服务 | 该账号 | 账号功能受限,直到人工解除 |
上线节奏同样要分阶段。新规则上线时先用「只观察不执行」的模式跑一段时间,观察疑似作弊的规模和准确率;确认无误报后再逐档放开执行力度。直接从「观察」跳到「拦截」的中间档位,是最容易出事故的做法。
核心指标监控
配置要点
- 配置表达的是环境差异和运行参数,不是业务规则本身。
- 队列、缓存、存储和服务参数决定系统在高峰期的缓冲能力。
告警规则
配置要点
- 配置表达的是环境差异和运行参数,不是业务规则本身。
监控大盘
配置要点
- 配置表达的是环境差异和运行参数,不是业务规则本身。
1. 分层防御
┌─────────────────────────────────────┐
│ 客户端防护层 │
│ - 设备指纹 - 行为验证 - 限流 │
└─────────────────┬───────────────────┘
│
┌─────────────────▼───────────────────┐
│ 网关防护层 │
│ - IP 限流 - 频率控制 - 黑名单 │
└─────────────────┬───────────────────┘
│
┌─────────────────▼───────────────────┐
│ 业务防护层 │
│ - 异常检测 - 规则引擎 - 机器学习 │
└─────────────────┬───────────────────┘
│
┌─────────────────▼───────────────────┐
│ 数据防护层 │
│ - 数据校验 - 审计日志 - 追溯分析 │
└─────────────────────────────────────┘
2. 持续优化
- 定期更新规则:根据新发现的作弊手段更新检测规则
- 模型迭代:定期重新训练机器学习模型
- 误报分析:分析误报案例,优化检测阈值
- 红队测试:定期进行对抗测试,发现系统漏洞
3. 灰度发布
新规则/模型发布流程:
1. 离线验证 → 2. 小流量实验 → 3. 逐步放量 → 4. 全量发布
↓ ↓ ↓ ↓
历史数据 1% 流量 10% → 50% 100% 流量
准确率评估 误报率监控 效果对比 全面监控
4. 人机协同
| 场景 | 自动处理 | 人工审核 |
|---|---|---|
| 低风险异常 | ✅ | ❌ |
| 中风险异常 | ✅ + 记录 | 抽样 |
| 高风险异常 | 临时限制 | ✅ |
| 严重异常 | 立即封禁 | ✅ + 追溯 |
5. 合规与隐私
- 数据最小化:只收集必要的检测数据
- 数据脱敏:存储时进行匿名化处理
- 用户告知:在隐私政策中说明检测机制
- 申诉机制:提供误封申诉渠道
异常检测是防作弊系统的核心技术,需要:
- 多维度特征:结合时间、设备、行为等多维度数据
- 多层次检测:规则、统计、机器学习相结合
- 实时响应:快速识别并处置异常行为
- 持续优化:根据对抗结果不断迭代改进
通过建立完善的异常检测体系,可以有效识别和防范刷榜行为,保障排行榜的公平性和可信度。
发现内容有问题?
告诉我们哪里需要改进。
