ClawHub Skills AI 文本人性化处理（Humanize AI text）技能使用参考手册

基于 Wikipedia 「AI 写作识别特征」指南开发的 AI 文本人性化处理工具，可改写 ChatGPT、Claude、GPT 等生成的文本，使其更自然并绕过 GPTZero、Turnitin、Originality.ai 等 AI 检测器。

一、工具简介

Humanize AI Text 是一套命令行工具集，核心功能包括AI 文本检测和文本人性化改写，通过识别并修正 AI 写作的典型特征（如机械话术、格式痕迹、引用漏洞等），让生成式 AI 文本具备人类写作的自然性，从而规避各类 AI 检测器的识别。

工具核心依据：维基百科 - AI 写作识别特征
版本信息：v1.0.1
支持功能：

• 检测 16 类 AI 写作典型特征
• 批量/单文件改写 AI 文本
• 对比改写前后的检测结果（问题数量、AI 概率等）

👤 作者：maximeprades
👉 Skills 下载地址：humanize-ai-text-1.0.1.zip

二、快速开始

2.1 基础命令

## 1. 检测文本中的 AI 特征
python scripts/detect.py 文本文件.txt


## 2. 将 AI 文本改写为人类风格（输出到新文件）
python scripts/transform.py 文本文件.txt -o 改写后文件.txt


## 3. 对比改写前后的检测结果（含问题数量、AI 概率变化）
python scripts/compare.py 文本文件.txt -o 改写后文件.txt

2.2 环境要求

• Python 3.6+
• 依赖：无（仅使用 Python 内置库：argparse、re、json、pathlib 等）
• 支持系统：Windows/macOS/Linux

三、核心功能详解

3.1 AI 文本检测（detect.py）

功能说明

扫描文本中 16 类 AI 写作特征，输出「问题总数、AI 概率（极低/低/中/高/极高）、特征分类统计」等信息，是改写文本的前置分析工具。

使用命令

## 基础检测（输出完整报告）
python scripts/detect.py essay.txt


## 输出 JSON 格式结果（便于程序调用）
python scripts/detect.py essay.txt -j


## 仅输出核心评分（问题数、词数、AI 概率）
python scripts/detect.py essay.txt -s


## 从标准输入读取文本（无需文件）
echo "AI 生成的文本内容" | python scripts/detect.py

输出说明

3.2 AI 文本改写（transform.py）

功能说明

自动修正 AI 文本中的典型特征，生成人类风格文本，支持「常规模式」和「激进模式」。

使用命令

## 基础改写（输出到控制台）
python scripts/transform.py essay.txt


## 改写并保存到文件
python scripts/transform.py essay.txt -o clean_essay.txt


## 激进模式改写（强化简化-ing 从句、减少破折号）
python scripts/transform.py essay.txt -a -o clean_essay.txt


## 静默模式（不输出改写日志）
python scripts/transform.py essay.txt -q -o clean_essay.txt

自动修正项

3.3 前后对比分析（compare.py）

功能说明

对比文本改写前后的检测结果，直观展示「问题数变化、AI 概率变化、改写细节」，验证改写效果。

使用命令

## 基础对比（输出控制台）
python scripts/compare.py essay.txt


## 对比并保存改写后的文本
python scripts/compare.py essay.txt -a -o clean_essay.txt

输出说明

四、AI 检测特征分类（16 类）

基于维基百科「AI 写作识别特征」整理，工具会针对以下特征进行检测/修正：

4.1 关键特征（直接触发 AI 检测）

4.2 高风险特征

4.3 中风险特征

4.4 风格特征

五、带中文注释的核心代码

5.1 detect.py（AI 文本检测）

#!/usr/bin/env python3
"""
AI 文本检测脚本（基于维基百科AI写作识别特征）
功能：扫描文本中的16类AI写作特征，输出检测结果（问题数、AI概率、特征分类）
"""
import argparse, json, re, sys
from pathlib import Path
from dataclasses import dataclass, field


## 脚本目录路径
SCRIPT_DIR = Path(__file__).parent
## 加载检测规则配置文件（AI特征库）
PATTERNS = json.loads((SCRIPT_DIR / "patterns.json").read_text())


## 检测结果数据结构
@dataclass
class DetectionResult:
    significance_inflation: list = field(default_factory=list)  # 意义夸大
    notability_emphasis: list = field(default_factory=list)     # 显著性强调
    superficial_analysis: list = field(default_factory=list)   # 表面化分析
    promotional_language: list = field(default_factory=list)   # 营销话术
    vague_attributions: list = field(default_factory=list)     # 模糊归因
    challenges_formula: list = field(default_factory=list)     # 固定挑战句式
    ai_vocabulary: list = field(default_factory=list)          # AI专属词汇
    copula_avoidance: list = field(default_factory=list)       # 动词规避
    filler_phrases: list = field(default_factory=list)         # 填充短语
    chatbot_artifacts: list = field(default_factory=list)      # 聊天机器人痕迹
    hedging_phrases: list = field(default_factory=list)        # 模糊措辞
    negative_parallelisms: list = field(default_factory=list)  # 否定并列
    rule_of_three: list = field(default_factory=list)          # 三段式套路
    markdown_artifacts: list = field(default_factory=list)     # Markdown格式
    citation_bugs: list = field(default_factory=list)          # 引用漏洞
    knowledge_cutoff: list = field(default_factory=list)       # 知识截止话术
    curly_quotes: int = 0                                      # 弯引号数量
    em_dashes: int = 0                                         # 破折号数量
    total_issues: int = 0                                      # 总问题数（加权）
    ai_probability: str = "low"                                # AI概率（low/medium/high/very high）
    word_count: int = 0                                        # 文本词数


## 匹配文本中的指定特征列表
def find_matches(text: str, patterns: list) -> list:
    matches, lower_text = [], text.lower()
    for pattern in patterns:
        count = lower_text.count(pattern.lower())  # 不区分大小写统计匹配数
        if count > 0:
            matches.append((pattern, count))
    # 按匹配数降序排列
    return sorted(matches, key=lambda x: -x[1])


## 核心检测逻辑
def detect(text: str) -> DetectionResult:
    r = DetectionResult()
    r.word_count = len(text.split())  # 统计词数（按空格分割）

    
    # 1. 匹配各类AI特征
    r.significance_inflation = find_matches(text, PATTERNS["significance_inflation"])
    r.notability_emphasis = find_matches(text, PATTERNS["notability_emphasis"])
    r.superficial_analysis = find_matches(text, PATTERNS["superficial_analysis"])
    r.promotional_language = find_matches(text, PATTERNS["promotional_language"])
    r.vague_attributions = find_matches(text, PATTERNS["vague_attributions"])
    r.challenges_formula = find_matches(text, PATTERNS["challenges_formula"])
    r.ai_vocabulary = find_matches(text, PATTERNS["ai_vocabulary"])
    r.copula_avoidance = find_matches(text, list(PATTERNS["copula_avoidance"].keys()))
    r.filler_phrases = find_matches(text, list(PATTERNS["filler_replacements"].keys()))
    r.chatbot_artifacts = find_matches(text, PATTERNS["chatbot_artifacts"])
    r.hedging_phrases = find_matches(text, PATTERNS["hedging_phrases"])
    r.negative_parallelisms = find_matches(text, PATTERNS["negative_parallelisms"])
    r.rule_of_three = find_matches(text, PATTERNS["rule_of_three_patterns"])
    r.markdown_artifacts = find_matches(text, PATTERNS["markdown_artifacts"])
    r.citation_bugs = find_matches(text, PATTERNS["citation_bugs"])
    r.knowledge_cutoff = find_matches(text, PATTERNS["knowledge_cutoff"])

    
    # 2. 统计特殊符号
    r.curly_quotes = len(re.findall(r'[""'']', text))  # 弯引号
    r.em_dashes = text.count("—") + text.count(" -- ")  # 破折号（两种格式）

    
    # 3. 计算加权总问题数（核心特征权重更高）
    r.total_issues = (
        sum(c for _, c in r.significance_inflation) + 
        sum(c for _, c in r.notability_emphasis) +
        sum(c for _, c in r.superficial_analysis) + 
        sum(c for _, c in r.promotional_language) +
        sum(c for _, c in r.vague_attributions) + 
        sum(c for _, c in r.challenges_formula) +
        sum(c for _, c in r.ai_vocabulary) + 
        sum(c for _, c in r.copula_avoidance) +
        sum(c for _, c in r.filler_phrases) + 
        sum(c for _, c in r.chatbot_artifacts) * 3 +  # 聊天机器人痕迹×3
        sum(c for _, c in r.hedging_phrases) + 
        sum(c for _, c in r.negative_parallelisms) +
        sum(c for _, c in r.markdown_artifacts) * 2 +  # Markdown格式×2
        sum(c for _, c in r.citation_bugs) * 5 +       # 引用漏洞×5（最高权重）
        sum(c for _, c in r.knowledge_cutoff) * 3 +   # 知识截止话术×3
        r.curly_quotes + 
        (r.em_dashes if r.em_dashes > 3 else 0)       # 破折号仅统计超过3个的部分
    )

    
    # 4. 判定AI概率
    density = r.total_issues / max(r.word_count, 1) * 100  # 问题密度（每100词）
    if r.citation_bugs or r.knowledge_cutoff or r.chatbot_artifacts:
        r.ai_probability = "very high"  # 含关键特征→极高
    elif density > 5 or r.total_issues > 30:
        r.ai_probability = "high"       # 高密度/高问题数→高
    elif density > 2 or r.total_issues > 15:
        r.ai_probability = "medium"     # 中密度/中问题数→中
    return r


## 打印分类检测结果
def print_section(title: str, items: list, replacements: dict = None):
    if not items:
        return
    print(f"{title}:")
    for phrase, count in items:
        if replacements and phrase in replacements:
            repl = replacements[phrase]
            arrow = f' → "{repl}"' if repl else " → (移除)"
            print(f"  • \"{phrase}\"{arrow}: {count}次")
        else:
            print(f"  • {phrase}: {count}次")
    print()


## 打印完整检测报告
def print_report(r: DetectionResult):
    icons = {"very high": "🔴", "high": "🟠", "medium": "🟡", "low": "🟢"}
    print(f"\n{'='*60}")
    print(f"AI 检测报告 - 总计 {r.total_issues} 个问题（{r.word_count} 词）")
    print(f"AI 概率: {icons.get(r.ai_probability, '')} {r.ai_probability.upper()}")
    print(f"{'='*60}\n")

    
    # 关键风险提示
    if r.citation_bugs:
        print("⚠️  高危：ChatGPT 引用漏洞")
        print_section("引用痕迹", r.citation_bugs)
    if r.knowledge_cutoff:
        print("⚠️  高危：知识截止话术")
        print_section("截止话术", r.knowledge_cutoff)
    if r.chatbot_artifacts:
        print("⚠️  高风险：聊天机器人痕迹")
        print_section("机器人话术", r.chatbot_artifacts)
    if r.markdown_artifacts:
        print("⚠️  风险：Markdown格式痕迹")
        print_section("Markdown标记", r.markdown_artifacts)

    
    # 其他特征分类展示
    print_section("意义夸大", r.significance_inflation)
    print_section("营销话术", r.promotional_language)
    print_section("AI专属词汇", r.ai_vocabulary)
    print_section("表面化-ing结构", r.superficial_analysis)
    print_section("动词规避", r.copula_avoidance, PATTERNS["copula_avoidance"])
    print_section("填充短语", r.filler_phrases, PATTERNS["filler_replacements"])
    print_section("模糊归因", r.vague_attributions)
    print_section("固定挑战句式", r.challenges_formula)
    print_section("模糊措辞", r.hedging_phrases)
    print_section("否定并列", r.negative_parallelisms)
    print_section("显著性强调", r.notability_emphasis)

    
    # 特殊符号统计
    if r.curly_quotes:
        print(f"弯引号数量: {r.curly_quotes} (ChatGPT 标志性特征)\n")
    if r.em_dashes > 3:
        print(f"破折号数量: {r.em_dashes} (使用过量)\n")
    if r.total_issues == 0:
        print("✓ 未检测到AI写作特征。\n")


## 主函数（命令行参数解析）
def main():
    parser = argparse.ArgumentParser(description="检测文本中的AI写作特征")
    parser.add_argument("input", nargs="?", help="输入文件路径（或从标准输入读取）")
    parser.add_argument("--json", "-j", action="store_true", help="输出JSON格式结果")
    parser.add_argument("--score-only", "-s", action="store_true", help="仅输出核心评分（问题数、词数、AI概率）")
    args = parser.parse_args()

    
    # 读取输入文本（文件/标准输入）
    text = Path(args.input).read_text() if args.input else sys.stdin.read()
    result = detect(text)

    
    # 按参数输出不同格式
    if args.json:
        print(json.dumps({
            "total_issues": result.total_issues, "word_count": result.word_count,
            "ai_probability": result.ai_probability, "significance_inflation": result.significance_inflation,
            "promotional_language": result.promotional_language, "ai_vocabulary": result.ai_vocabulary,
            "chatbot_artifacts": result.chatbot_artifacts, "citation_bugs": result.citation_bugs,
            "filler_phrases": result.filler_phrases, "curly_quotes": result.curly_quotes, "em_dashes": result.em_dashes,
        }, indent=2, ensure_ascii=False))  # 保留中文
    elif args.score_only:
        print(f"问题数: {result.total_issues} | 词数: {result.word_count} | AI概率: {result.ai_probability}")
    else:
        print_report(result)


if __name__ == "__main__":
    main()

5.2 transform.py（AI 文本改写）

#!/usr/bin/env python3
"""
AI 文本改写脚本
功能：修正AI文本中的典型特征，生成人类风格文本，支持常规/激进模式
"""
import argparse, json, re, sys
from pathlib import Path


## 脚本目录路径
SCRIPT_DIR = Path(__file__).parent
## 加载改写规则配置文件
PATTERNS = json.loads((SCRIPT_DIR / "patterns.json").read_text())


## 替换文本中的指定内容（边界匹配，避免部分匹配）
def replace_bounded(text: str, old: str, new: str) -> tuple[str, int]:
    # 短语/带逗号的内容：不区分大小写；单个单词：按单词边界匹配
    if " " in old or old.endswith(","):
        pattern = re.compile(re.escape(old), re.IGNORECASE)
    else:
        pattern = re.compile(r"\b" + re.escape(old) + r"\b", re.IGNORECASE)

    
    matches = pattern.findall(text)
    # 替换内容（有匹配才替换）
    new_text = pattern.sub(new, text) if matches else text
    return new_text, len(matches)


## 批量应用替换规则
def apply_replacements(text: str, replacements: dict) -> tuple[str, list]:
    changes = []  # 记录修改项
    for old, new in replacements.items():
        text, count = replace_bounded(text, old, new)
        if count:
            if new:
                changes.append(f'"{old}" → "{new}"')
            else:
                changes.append(f'"{old}" 已移除')
    return text, changes


## 修正弯引号为直引号（ChatGPT标志性特征）
def fix_quotes(text: str) -> tuple[str, bool]:
    original = text
    for old_quote, new_quote in PATTERNS["curly_quotes"].items():
        text = text.replace(old_quote, new_quote)
    # 返回修正后文本 + 是否修改
    return text, text != original


## 移除聊天机器人话术（如「I hope this helps」「As an AI」）
def remove_chatbot_sentences(text: str) -> tuple[str, list]:
    changes = []
    for artifact in PATTERNS["chatbot_artifacts"]:
        # 匹配包含该话术的整句（非.!?\n分隔）
        pattern = re.compile(r"[^.!?\n]*" + re.escape(artifact) + r"[^.!?\n]*[.!?]?\s*", re.IGNORECASE)
        if pattern.search(text):
            changes.append(f'移除包含"{artifact}"的句子')
            text = pattern.sub("", text)  # 移除整句
    return text, changes


## 移除Markdown格式痕迹（粗体、标题、代码块）
def strip_markdown(text: str) -> tuple[str, list]:
    changes = []
    if "**" in text:
        text = re.sub(r'\*\*([^*]+)\*\*', r'\1', text)  # 移除粗体标记
        changes.append("移除粗体格式")
    if re.search(r'^#{1,6}\s', text, re.MULTILINE):
        text = re.sub(r'^#{1,6}\s+', '', text, flags=re.MULTILINE)  # 移除标题标记
        changes.append("移除标题格式")
    if "```" in text:
        text = re.sub(r'```\w*\n?', '', text)  # 移除代码块标记
        changes.append("移除代码块格式")
    return text, changes


## 减少破折号使用（替换为逗号）
def reduce_em_dashes(text: str) -> tuple[str, int]:
    # 统计破折号数量（两种格式）
    count = text.count("—") + text.count(" -- ")
    text = re.sub(r"\s*—\s*", ", ", text)    # 替换em破折号
    text = re.sub(r"\s+--\s+", ", ", text)   # 替换双连字符
    return text, count


## 移除AI引用漏洞标记（如oaicite、turn0search）
def remove_citations(text: str) -> tuple[str, list]:
    changes = []
    # 引用漏洞正则匹配规则
    patterns = [
        (r'\[oai_citation:\d+[^\]]*\]\([^)]+\)', "oai_citation引用标记"),
        (r':contentReference\[oaicite:\d+\]\{[^}]+\}', "contentReference引用标记"),
        (r'turn0search\d+', "turn0search标记"), 
        (r'turn0image\d+', "turn0image标记"),
        (r'\?utm_source=(chatgpt\.com|openai)', "ChatGPT UTM参数"),
    ]
    for pattern, name in patterns:
        if re.search(pattern, text):
            text = re.sub(pattern, '', text)
            changes.append(f"移除{name}")
    return text, changes


## 简化-ing从句（激进模式）
def simplify_ing(text: str) -> tuple[str, list]:
    changes = []
    # 需简化的-ing关键词
    for word in ["highlighting", "underscoring", "emphasizing", "showcasing", "fostering"]:
        # 匹配包含该词的从句
        pattern = re.compile(rf',?\s*{word}\s+[^,.]+[,.]', re.IGNORECASE)
        if pattern.search(text):
            text = pattern.sub('. ', text)  # 简化为句点分隔
            changes.append(f"简化{word}从句")
    return text, changes


## 文本清理（多余空格、换行、逗号，首字母大写）
def clean(text: str) -> str:
    text = re.sub(r" +", " ", text)  # 多个空格→单个
    text = re.sub(r"\n{3,}", "\n\n", text)  # 三个以上换行→两个
    text = re.sub(r",\s*,", ",", text)  # 多余逗号
    # 句子首字母大写（.?!后接小写字母）
    text = re.sub(r"(^|[.!?]\s+)([a-z])", lambda m: m.group(1) + m.group(2).upper(), text)
    return text.strip()  # 移除首尾空格


## 核心改写逻辑
def transform(text: str, aggressive: bool = False) -> tuple[str, list]:
    all_changes = []  # 记录所有修改项

    
    # 1. 移除引用漏洞
    text, changes = remove_citations(text); all_changes.extend(changes)
    # 2. 移除Markdown格式
    text, changes = strip_markdown(text); all_changes.extend(changes)
    # 3. 移除聊天机器人话术
    text, changes = remove_chatbot_sentences(text); all_changes.extend(changes)
    # 4. 修正动词规避
    text, changes = apply_replacements(text, PATTERNS["copula_avoidance"]); all_changes.extend(changes)
    # 5. 简化填充短语
    text, changes = apply_replacements(text, PATTERNS["filler_replacements"]); all_changes.extend(changes)
    # 6. 修正弯引号
    text, fixed = fix_quotes(text)
    if fixed:
        all_changes.append("修正弯引号为直引号")

    
    # 7. 激进模式额外优化
    if aggressive:
        # 简化-ing从句
        text, changes = simplify_ing(text); all_changes.extend(changes)
        # 减少破折号
        text, count = reduce_em_dashes(text)
        if count > 2:
            all_changes.append(f"替换{count}个破折号为逗号")

    
    # 8. 最终文本清理
    return clean(text), all_changes


## 主函数（命令行参数解析）
def main():
    parser = argparse.ArgumentParser(description="将AI文本改写为人类风格")
    parser.add_argument("input", nargs="?", help="输入文件路径（或从标准输入读取）")
    parser.add_argument("-o", "--output", help="输出文件路径（保存改写后文本）")
    parser.add_argument("-a", "--aggressive", action="store_true", help="激进模式（强化改写）")
    parser.add_argument("-q", "--quiet", action="store_true", help="静默模式（不输出修改日志）")
    args = parser.parse_args()

    
    # 读取输入文本
    text = Path(args.input).read_text() if args.input else sys.stdin.read()
    # 执行改写
    result, changes = transform(text, aggressive=args.aggressive)

    
    # 输出修改日志（非静默模式）
    if not args.quiet and changes:
        print(f"修改项（共{len(changes)}项）：", file=sys.stderr)
        for change in changes:
            print(f"  • {change}", file=sys.stderr)

    
    # 保存到文件/输出到控制台
    if args.output:
        Path(args.output).write_text(result)
        if not args.quiet:
            print(f"→ 改写后文本已保存到 {args.output}", file=sys.stderr)
    else:
        print(result)


if __name__ == "__main__":
    main()

5.3 compare.py（前后对比）

#!/usr/bin/env python3
"""
AI文本改写前后对比脚本
功能：对比文本改写前后的检测结果，展示问题数、AI概率、词数变化
"""
import argparse, sys
from pathlib import Path
from detect import detect  # 导入检测函数
from transform import transform  # 导入改写函数


def main():
    # 解析命令行参数
    parser = argparse.ArgumentParser(description="对比AI文本改写前后的检测结果")
    parser.add_argument("input", nargs="?", help="输入文件路径（或从标准输入读取）")
    parser.add_argument("-a", "--aggressive", action="store_true", help="使用激进模式改写")
    parser.add_argument("-o", "--output", help="改写后文本的保存路径")
    args = parser.parse_args()

    
    # 读取输入文本
    text = Path(args.input).read_text() if args.input else sys.stdin.read()

    
    # 1. 检测改写前的文本
    before = detect(text)
    # 2. 执行改写
    transformed, changes = transform(text, aggressive=args.aggressive)
    # 3. 检测改写后的文本
    after = detect(transformed)

    
    # AI概率对应图标
    icons = {"very high": "🔴", "high": "🟠", "medium": "🟡", "low": "🟢"}

    
    # 打印对比表头
    print(f"\n{'='*60}")
    print("改写前后对比报告")
    print(f"{'='*60}\n")

    
    print(f"{'指标':<25} {'改写前':<15} {'改写后':<15} {'变化':<10}")
    print(f"{'-'*60}")

    
    # 问题数变化
    issue_diff = after.total_issues - before.total_issues
    issue_sign = "+" if issue_diff > 0 else ""  # 正数加+号
    print(f"{'问题总数':<25} {before.total_issues:<15} {after.total_issues:<15} {issue_sign}{issue_diff}")

    
    # AI概率变化
    before_ai = f"{icons.get(before.ai_probability,'')} {before.ai_probability:<12}"
    after_ai = f"{icons.get(after.ai_probability,'')} {after.ai_probability:<12}"
    print(f"{'AI概率':<25} {before_ai} {after_ai}")

    
    # 词数变化
    word_diff = after.word_count - before.word_count
    print(f"{'词数':<25} {before.word_count:<15} {after.word_count:<15} {word_diff:+}")

    
    # 打印改写细节
    if changes:
        print(f"\n{'='*60}")
        print(f"改写详情（共{len(changes)}项）")
        print(f"{'='*60}")
        for change in changes:
            print(f"  • {change}")

    
    # 打印优化/恶化结果
    reduction = before.total_issues - after.total_issues
    if reduction > 0:
        # 计算优化百分比
        pct = (reduction / before.total_issues * 100) if before.total_issues else 0
        print(f"\n✓ 减少 {reduction} 个问题（优化 {pct:.0f}%）")
    elif reduction < 0:
        print(f"\n⚠ 问题数增加 {-reduction} 个")
    else:
        print(f"\n— 问题数无变化")

    
    # 保存改写后文本
    if args.output:
        Path(args.output).write_text(transformed)
        print(f"\n→ 改写后文本已保存到 {args.output}")


if __name__ == "__main__":
    main()

六、完整使用流程

步骤1：检测文本风险

## 扫描文本，确认AI特征分布
python scripts/detect.py my_essay.txt

输出示例：

============================================================
AI 检测报告 - 总计 28 个问题（500 词）
AI 概率: 🟠 HIGH
============================================================


⚠️  高危：聊天机器人痕迹
机器人话术:
  • "As an AI": 1次


⚠️  风险：Markdown格式痕迹
Markdown标记:
  • "**": 3次


意义夸大:
  • "pivotal moment": 2次
...

步骤2：改写文本并验证

## 激进模式改写并保存，同时对比结果
python scripts/compare.py my_essay.txt -a -o my_essay_human.txt

输出示例：

============================================================
改写前后对比报告
============================================================


指标                       改写前           改写后           变化
------------------------------------------------------------
问题总数                   28              7               -21
AI概率                     🟠 high         🟢 low          
词数                       500             489             -11


============================================================
改写详情（共12项）
============================================================
  • 移除包含"As an AI"的句子
  • 移除粗体格式
  • "pivotal moment" → "important moment"
  • 修正弯引号为直引号
...


✓ 减少 21 个问题（优化 75%）
→ 改写后文本已保存到 my_essay_human.txt

步骤3：最终验证

## 检测改写后的文本，确认AI概率达标
python scripts/detect.py my_essay_human.txt -s

输出示例：

问题数: 7 | 词数: 489 | AI概率: low

七、批量处理

7.1 批量检测所有文本文件

## 遍历当前目录下所有.txt文件，输出核心评分
for f in *.txt; do
  echo "=== $f ==="
  python scripts/detect.py "$f" -s
done

7.2 批量改写所有Markdown文件

## 遍历当前目录下所有.md文件，激进模式改写并保存为*_clean.md
for f in *.md; do
  python scripts/transform.py "$f" -a -o "${f%.md}_clean.md" -q
done

八、自定义改写规则

示例：新增自定义填充短语替换

"filler_replacements": {
  // 原有规则
  "in order to": "to",
  // 新增规则
  "for the purpose of": "to",
  "on the basis of": "based on"
}