File size: 10,231 Bytes
4a0f6a5 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Pattern-based rule engine for AI-text detection.
Design principles:
1. No human-keywords (easily spoofed and noisy).
2. AI indicators are structural / rhetorical patterns, not single words.
3. Rules are registerable at runtime to stay ahead of adversarial paraphrasing.
4. Scoring is length-normalised so long texts do not artificially inflate hits.
"""
from __future__ import annotations
import re
from dataclasses import dataclass
from typing import Dict, List, Tuple
@dataclass
class PatternRule:
"""A single detection rule comprised of one or more regex patterns."""
rid: str
name: str
patterns: List[str]
weight: float = 1.0
category: str = "syntax"
enabled: bool = True
# ---------------------------------------------------------------------------
# Default rule bank – these target *stylistic fingerprints* rather than
# overt self-references, making them harder for an adversary to guess and
# avoid with simple synonym replacement.
# ---------------------------------------------------------------------------
DEFAULT_RULES: List[PatternRule] = [
PatternRule(
rid="ai_struct_not_but",
name="不是-而是结构",
patterns=[r"不是[^，,。.!！?？]{0,30}而是"],
weight=1.0,
category="syntax",
),
PatternRule(
rid="ai_praise_grasp",
name="赞扬精准抓住",
patterns=[
r"你\s*(非常|很|真的|确实)?\s*(精准|准确|精确)?\s*(地|的)?\s*抓住\s*了\s*这\s*(一)?\s*点",
r"你\s*(非常|很|真的)?\s*(懂|理解|说到|指出)",
],
weight=1.0,
category="rhetoric",
),
PatternRule(
rid="ai_praise_textbook",
name="教科书级别",
patterns=[
r"(教科书|标杆|模板|标准|典范|参考级)(级别|级|式|一样|般)的(理解|回答|分析|解读|阐述|表达|总结)",
r"(堪称|可谓|可以算是|几乎就是)\s*(教科书|标杆|模板|标准)",
],
weight=1.0,
category="rhetoric",
),
PatternRule(
rid="ai_praise_correct",
name="完全正确赞扬",
patterns=[
r"你说\s*(的)?\s*(完全|非常|十分|绝对|确实|太)?\s*正确",
r"你\s*(说|讲|理解|看)\s*(得|的)?\s*(完全|非常|十分|绝对|确实|很|太)?\s*(对|到位|透彻)",
],
weight=1.0,
category="rhetoric",
),
PatternRule(
rid="ai_quote_abuse",
name="双引号滥用",
patterns=[r"([\"\"\"\"]).{2,40}?\1.{0,10}?\1.{2,40}?\1"],
weight=0.8,
category="style",
),
PatternRule(
rid="ai_summary_transition",
name="总结过渡词",
patterns=[
r"(总的来说|综上所述|一言以蔽之|简而言之|总的来看).{0,5}[，,]",
r"(首先|其次|再者|最后|一方面|另一方面).{0,5}[，,]",
],
weight=0.5,
category="syntax",
),
PatternRule(
rid="ai_modal_weak",
name="弱化确定性",
patterns=[
r"(可能|也许|某种程度上|一定程度上|大致|基本).{0,10}(可以|算是|认为|看作)",
r"(不\s*(排除|否定|否认|确定|保证))",
],
weight=0.4,
category="style",
),
PatternRule(
rid="ai_self_reference",
name="AI自我指涉",
patterns=[
r"(作为|身为)\s*(一个|一名)?\s*(AI|人工智能|语言模型|大模型|助手)",
r"(我\s*(是|作为)\s*(一个|一名)?\s*(AI|人工智能|语言模型|大模型|助手))",
r"(没有|不\s*(具备|拥有))[^，,。.!！?？]{0,20}(情感|主观|个人经历|身体|人类)",
],
weight=1.2,
category="identity",
),
# -----------------------------------------------------------------------
# Community-contributed rules based on human intuitions about AI text.
# -----------------------------------------------------------------------
PatternRule(
rid="ai_struct_not_ext",
name="不是-而是排比扩展",
patterns=[r"不是[^，,。.!！?？]{0,40}(而是|是|他更)[^，,。.!！?？]{0,20}(更|还)"],
weight=1.0,
category="syntax",
),
PatternRule(
rid="ai_meta_discourse",
name="论述结构预告",
patterns=[
r"我分(几个|几)\s*个?(层面|维度)[来给]*你",
r"一句话给[你]*[一个]*最[稳准狠]",
r"从(几个|多)\s*个(维度|层面|角度)",
],
weight=0.8,
category="syntax",
),
PatternRule(
rid="ai_flattery_open",
name="赞扬式开场",
patterns=[
r"你的(观察|洞察|直觉)\s*(非常|很|真的)?\s*(敏锐|精准|到位)",
r"你[说讲看]*\s*(得|的)?\s*(非常|很|太)?\s*(对|到位|透彻|准确)",
],
weight=1.0,
category="rhetoric",
),
PatternRule(
rid="ai_over_agree",
name="过度认同+自我否定",
patterns=[
r"你说的对，我(完全|确实)?\s*(搞错|误解|想错)",
r"你看到了(事情|问题)?\s*的?本质",
],
weight=1.0,
category="rhetoric",
),
PatternRule(
rid="ai_service_push",
name="服务性追问",
patterns=[
r"你现在感觉怎么样",
r"要不要我帮[你]*",
],
weight=0.8,
category="rhetoric",
),
PatternRule(
rid="ai_poetic_cliche",
name="诗意化比喻堆砌",
patterns=[
r"(时光|岁月|往事|记忆)\s*的?\s*(褶皱|琥珀|潮汐|甬道)",
r"如[^，,。.!！?？]{0,20}(月光|星光)[^，,。.!！?？]{0,20}(潮汐|涟漪)",
r"被封存在[^，,。.!！?？]{0,20}般?的?暮色",
],
weight=1.0,
category="style",
),
PatternRule(
rid="ai_list_numeric",
name="数字分点结构",
patterns=[
r"1\.\s+.{3,40}[\n\r]+2\.\s+.{3,40}",
r"一[、．.]\s*.{3,40}[\n\r]+二[、．.]\s*.{3,40}",
],
weight=0.6,
category="style",
),
PatternRule(
rid="ai_markdown_bold",
name="Markdown粗体外泄",
patterns=[r"\*\*[^*]+\*\*"],
weight=0.5,
category="style",
),
PatternRule(
rid="ai_honesty_preface",
name="说实话前置",
patterns=[r"[，,]\s*说实(话|在的)[，,]"],
weight=0.4,
category="style",
),
PatternRule(
rid="ai_perspective_close",
name="视角收尾",
patterns=[r"接近你?现在[^，,。.!！?？]{0,20}的?视角"],
weight=0.4,
category="style",
),
]
class RuleEngine:
"""Compiles and evaluates a set of PatternRules."""
def __init__(self, rules: List[PatternRule] | None = None):
self.rules: List[PatternRule] = list(rules) if rules is not None else []
self._compiled: Dict[str, re.Pattern] = {}
self._compile_all()
def _compile_all(self) -> None:
for r in self.rules:
if not r.enabled:
continue
for idx, pat in enumerate(r.patterns):
key = f"{r.rid}_{idx}"
self._compiled[key] = re.compile(pat)
def register(self, rule: PatternRule) -> None:
"""Add a new rule at runtime (useful for rapid adversarial response)."""
self.rules.append(rule)
if rule.enabled:
for idx, pat in enumerate(rule.patterns):
self._compiled[f"{rule.rid}_{idx}"] = re.compile(pat)
def score(self, text: str) -> Tuple[float, Dict[str, int], int]:
"""Return (normalised_score, hit_map, active_rule_count)."""
t = str(text)
hits: Dict[str, int] = {}
total_weighted_hits = 0.0
for r in self.rules:
if not r.enabled:
continue
cnt = 0
for idx, _ in enumerate(r.patterns):
key = f"{r.rid}_{idx}"
pat = self._compiled.get(key)
if pat:
cnt += len(pat.findall(t))
if cnt:
hits[r.rid] = cnt
total_weighted_hits += cnt * r.weight
# Normalise by sqrt(length) so long texts do not game the score.
normalized_score = total_weighted_hits / (len(t) ** 0.5 + 1.0)
active_count = sum(1 for r in self.rules if r.enabled)
return float(normalized_score), hits, active_count
def explain(self, text: str) -> List[Dict[str, object]]:
"""Produce a human-readable diagnosis of which rules fired."""
t = str(text)
out: List[Dict[str, object]] = []
for r in self.rules:
if not r.enabled:
continue
matches: List[str] = []
for idx, _ in enumerate(r.patterns):
key = f"{r.rid}_{idx}"
pat = self._compiled.get(key)
if pat:
found = pat.findall(t)
if found:
matches.extend(str(m) for m in found)
if matches:
out.append(
{
"rid": r.rid,
"name": r.name,
"category": r.category,
"matches": matches[:10],
"count": len(matches),
"weight": r.weight,
}
)
return out
# Global default engine – imported by model_utils and experiment scripts.
_DEFAULT_ENGINE = RuleEngine(DEFAULT_RULES)
def rule_score(text: str, engine: RuleEngine | None = None) -> Tuple[float, Dict[str, int], int]:
"""Backward-compatible entry point."""
eng = engine or _DEFAULT_ENGINE
return eng.score(text)
def rule_explain(text: str, engine: RuleEngine | None = None) -> List[Dict[str, object]]:
"""Diagnostic entry point."""
eng = engine or _DEFAULT_ENGINE
return eng.explain(text)
|