一份旨在降低 AI 生成内容检测概率的智能文本处理工具 - 详细项目文档 (v3.3)
随着ChatGPT、Claude、通义千问等大型语言模型 (LLM) 的飞速发展与广泛应用，人工智能生成内容 (AIGC) 已深度渗透到科研、教育、创作等多个领域。根据国际教育科技研究机构的数据，2023年已有超过70%的高校学生使用过AI辅助写作，近50%的企业内容创作也依赖AI工具。
然而，这一趋势同时引发了学术诚信、内容原创性和过度依赖AI的担忧。作为回应，各类AI检测工具如Turnitin AI Writing Check、GPTZero、ZeroGPT、Copyleaks AI Content Detector等应运而生，通过分析文本的统计特征、词汇多样性、句式复杂度等指标来判断内容是否由AI生成。根据最新研究，这些检测工具对于未经修改的AI输出准确率可达80%-95%。
本项目开发的"文本降AI检测率工具"定位于这一技术生态的平衡点，旨在帮助用户对AI辅助生成的初稿进行智能优化。通过模拟人类自然写作的语言特征和思维逻辑，保留原文核心语义的同时，降低被主流AI检测工具判定为机器生成内容的概率。
本工具主要适用于以下场景：
本工具严格秉持"辅助创作，非替代思考"的理念，强调：
AI检测工具主要基于以下几种特征识别机器生成文本：
基于对这些特征的深入分析，本工具采用多层次、多策略的处理方法来调整文本特征，使其更接近人类自然写作风格。
系统使用精心设计的正则表达式模式（见 constants.py 中的 TITLE_PATTERNS, MATH_FORMULA_PATTERNS, PROTECTED_PATTERNS）自动检测文本中需要保护的结构元素：
# 保护模式示例（简化版）
TITLE_PATTERNS = [
r"^#+\s+.+$", # Markdown标题
r"^(?:Chapter|Section)\s+\d+", # 章节标记
r"^\d+(\.\d+)*\s+[A-Z]" # 编号标题
]
MATH_FORMULA_PATTERNS = [
r"\$\$.+?\$\$", # LaTeX公式块
r"\\\(.+?\\\)", # 行内LaTeX公式
r"\\begin\{equation\}.+?\\end\{equation\}" # 方程环境
]
PROTECTED_PATTERNS = [
r"```[\s\S]+?```", # 代码块
r"`[^`]+`", # 行内代码
r">\s.+", # 引用块
r"\[\^.+?\]", # 脚注
r"\[.+?\]\(.+?\)" # 链接
]这些元素在处理过程中被完整保留，确保专业内容、格式标记和重要结构不受影响。保护机制的实现通过core.py中的extract_protected_segments函数完成：
def extract_protected_segments(text, patterns=None):
"""提取需要保护的文本段落，返回保护区域的位置和内容"""
protected_segments = []
patterns = patterns or PROTECTED_PATTERNS
for pattern in patterns:
for match in re.finditer(pattern, text, re.MULTILINE):
start, end = match.span()
protected_segments.append((start, end, text[start:end]))
# 合并重叠区域并排序
if protected_segments:
protected_segments.sort(key=lambda x: x[0])
merged_segments = [protected_segments[0]]
for current in protected_segments[1:]:
prev = merged_segments[-1]
if current[0] <= prev[1]:
# 处理重叠
merged_segments[-1] = (
prev[0],
max(prev[1], current[1]),
text[prev[0]:max(prev[1], current[1])]
)
else:
merged_segments.append(current)
return merged_segments
return []用户可通过GUI界面或直接编辑data/protected_terms.json文件添加需要保护的专业术语、人名、地名等关键词。这些词汇在处理过程中会被跳过，确保专业准确性和上下文一致性。系统通过text_processor.py/load_protected_terms函数加载并应用这些保护词：
def load_protected_terms(file_path="data/protected_terms.json"):
"""加载用户自定义的保护词列表"""
try:
if os.path.exists(file_path):
with open(file_path, 'r', encoding='utf-8') as f:
terms = json.load(f)
# 按长度降序排列，优先匹配最长的词组
return sorted(terms, key=len, reverse=True)
return []
except Exception as e:
logger.error(f"加载保护词失败: {e}")
return []系统使用精确的位置记录和映射方法，确保只处理非保护区域。具体通过core.py/process_text_with_protection函数实现：
def process_text_with_protection(text, process_func, **kwargs):
"""在保护特定区域的前提下处理文本
Args:
text: 原始文本
process_func: 处理函数，接收非保护文本和其他参数
**kwargs: 传递给process_func的额外参数
Returns:
处理后的文本，保护区域保持不变
"""
# 提取所有需要保护的区域
protected_segments = extract_protected_segments(text)
if not protected_segments:
# 无保护区域，直接处理全文
return process_func(text, **kwargs)
# 构建非保护区域的文本片段
non_protected = []
last_end = 0
for start, end, _ in protected_segments:
if start > last_end:
non_protected.append(text[last_end:start])
last_end = end
if last_end < len(text):
non_protected.append(text[last_end:])
# 处理非保护区域
processed_non_protected = [
process_func(segment, **kwargs) if segment.strip() else segment
for segment in non_protected
]
# 重建完整文本
result = []
for i, (start, end, protected_text) in enumerate(protected_segments):
if i == 0 and start > 0:
result.append(processed_non_protected.pop(0))
result.append(protected_text)
if i < len(processed_non_protected):
result.append(processed_non_protected[i])
if processed_non_protected and len(protected_segments) < len(processed_non_protected):
result.append(processed_non_protected[-1])
return ''.join(result)系统内置了包含超过20,000个中文和15,000个英文词条的同义词库（data/synonyms_cn.json, data/synonyms_en.json）。词库构建采用了多源融合方法，结合以下数据源：
词库加载通过text_processor.py/load_synonym_database实现：
def load_synonym_database(language="cn"):
"""加载同义词数据库
Args:
language: 'cn'为中文, 'en'为英文
Returns:
同义词字典 {原词: [同义词列表]}
"""
file_path = f"data/synonyms_{language}.json"
try:
if not os.path.exists(file_path):
logger.warning(f"同义词库文件{file_path}不存在，将创建空数据库")
return {}
with open(file_path, 'r', encoding='utf-8') as f:
synonyms = json.load(f)
return synonyms
except Exception as e:
logger.error(f"加载同义词库失败: {e}")
return {}同义词替换策略通过text_processor.py/replace_with_synonyms实现，包含词频加权、上下文感知和随机性控制：
def replace_with_synonyms(text, synonym_db, strategy="MODERATE", protected_terms=None):
"""使用同义词替换文本中的词语
Args:
text: 输入文本
synonym_db: 同义词数据库
strategy: 替换策略 - LIGHT/MODERATE/AGGRESSIVE
protected_terms: 保护词列表
Returns:
替换后的文本
"""
if not text or not synonym_db:
return text
# 替换概率配置
prob_config = {
"LIGHT": 0.15, # 轻度替换，15%概率
"MODERATE": 0.30, # 中度替换，30%概率
"AGGRESSIVE": 0.45 # 激进替换，45%概率
}
replace_prob = prob_config.get(strategy, 0.30)
words = list(jieba.cut(text)) if detect_language(text) == "cn" else text.split()
result = []
for word in words:
# 检查是否为保护词
if protected_terms and any(term in word for term in protected_terms):
result.append(word)
continue
# 应用替换概率
if word in synonym_db and random.random() < replace_prob:
synonyms = synonym_db[word]
# 权重随机选择 (更常用的同义词有更高的选择概率)
weights = [1.0/(i+1) for i in range(len(synonyms))]
replacement = random.choices(synonyms, weights=weights, k=1)[0]
result.append(replacement)
else:
result.append(word)
# 根据原文语言重新组合
if detect_language(text) == "cn":
return ''.join(result)
else:
return ' '.join(result)当配置了有效的API密钥且启用高级模式时，系统会通过api_client.py调用外部LLM服务，提供更符合上下文的同义词建议。API请求使用异步方式实现，支持参数控制、错误重试和自动模型切换：
async def get_synonyms_api(word, context, api_key, model="gemini-pro"):
"""通过API获取更符合上下文的同义词建议
Args:
word: 需要替换的词
context: 词语所在的上下文
api_key: API密钥
model: 使用的模型
Returns:
同义词列表
"""
prompt = f"""
请为词语"{word}"提供5个在以下上下文中适合的同义词或近义词，保持词性一致:
上下文: {context}
只返回逗号分隔的同义词列表，不要其他解释。
"""
response = await call_api_with_retry(
api_key=api_key,
model=model,
prompt=prompt,
max_retries=3,
temperature=0.3
)
if response:
# 解析响应，提取同义词列表
synonyms = []
for line in response.strip().split('\n'):
words = re.sub(r'[^\w\s,]', '', line).split(',')
synonyms.extend([w.strip() for w in words if w.strip()])
return synonyms
return []系统包含一套精心设计的句式转换模板库 (data/sentence_patterns.json)，这些模板针对常见的AI生成文本特征进行调整。模板库涵盖：
模板应用通过text_processor.py/apply_sentence_patterns函数实现：
def apply_sentence_patterns(text, patterns, strategy="MODERATE"):
"""应用句式模板转换
Args:
text: 输入文本
patterns: 句式模板字典
strategy: 替换策略 - LIGHT/MODERATE/AGGRESSIVE
Returns:
处理后的文本
"""
if not text or not patterns:
return text
# 应用概率配置
prob_config = {
"LIGHT": 0.25, # 轻度改写，25%概率
"MODERATE": 0.50, # 中度改写，50%概率
"AGGRESSIVE": 0.80 # 激进改写，80%概率
}
apply_prob = prob_config.get(strategy, 0.50)
# 检查文本是否匹配任何模板
for pattern, replacements in patterns.items():
if random.random() > apply_prob:
continue # 根据策略概率决定是否尝试此模板
# 使用正则表达式进行模式匹配和替换
if re.search(pattern, text):
# 从可能的替换中随机选择一个
replacement = random.choice(replacements)
text = re.sub(pattern, replacement, text)
return text在ADVANCED模式下，系统会利用外部LLM API进行更深层次的句子改写。这一过程通过core.py/rewrite_sentence函数实现：
async def rewrite_sentence(sentence, api_key, style="default", fusion=False):
"""使用AI API进行句子深度改写
Args:
sentence: 需要改写的句子
api_key: API密钥
style: 改写风格 (default|formal|casual|complex|simple)
fusion: 是否启用融合改写
Returns:
改写后的句子
"""
# 不同改写风格的提示模板
style_prompts = {
"default": "请改写以下句子，保持原意但使用不同的表达方式:",
"formal": "请将以下句子改写为更正式、学术化的表达，保持原意:",
"casual": "请将以下句子改写为更口语化、自然的表达，保持原意:",
"complex": "请将以下句子改写为更复杂、词汇丰富的表达，保持原意:",
"simple": "请将以下句子改写为更简洁、清晰的表达，保持原意:"
}
# 构建改写提示
prompt_template = style_prompts.get(style, style_prompts["default"])
prompt = f"{prompt_template}\n\n{sentence}\n\n只返回改写后的句子，不要解释。"
if not fusion:
# 基础改写模式 - 直接返回API结果
response = await call_api_with_retry(
api_key=api_key,
prompt=prompt,
temperature=0.7, # 较高的温度以增加变化
max_retries=3
)
return response.strip() if response else sentence
else:
# 融合改写模式 - 生成多个候选并选择最佳
return await fusion_rewrite(sentence, api_key, prompt)
当启用"融合改写"选项时，系统会生成多个改写候选版本，通过先进的语义相似度分析和差异度评估，选择最佳结果。核心实现在fusion_rewrite函数中：
async def fusion_rewrite(original, api_key, prompt, candidates_count=3):
"""融合改写技术 - 生成多个候选并选择最佳
Args:
original: 原始句子
api_key: API密钥
prompt: 改写提示
candidates_count: 生成的候选数量
Returns:
最优的改写结果
"""
# 1. 生成多个候选版本
candidates = []
for i in range(candidates_count):
# 每次使用不同的温度以增加多样性
temp = 0.5 + (i * 0.3) # 0.5, 0.8, 1.1...
response = await call_api_with_retry(
api_key=api_key,
prompt=prompt,
temperature=min(temp, 1.4), # 最高限制在1.4
max_retries=2
)
if response and len(response.strip()) > 10: # 确保有效响应
candidates.append(response.strip())
# 如果没有有效候选，返回原句
if not candidates:
return original
# 2. 加载句子向量模型
try:
from sentence_transformers import SentenceTransformer
model = SentenceTransformer('all-MiniLM-L6-v2',
cache_folder='~/.anti_ai_detector/model_cache/')
# 3. 计算语义相似度
original_embedding = model.encode([original])[0]
candidate_embeddings = model.encode(candidates)
# 计算余弦相似度
similarities = []
for emb in candidate_embeddings:
similarity = cosine_similarity(original_embedding, emb)
similarities.append(similarity)
# 4. 计算表达差异度
import Levenshtein
differences = []
for cand in candidates:
# 归一化的Levenshtein距离，0-1范围
norm_distance = Levenshtein.distance(original, cand) / max(len(original), len(cand))
differences.append(norm_distance)
# 5. 选择语义相似且表达差异大的候选
valid_candidates = []
for i, (sim, diff) in enumerate(zip(similarities, differences)):
# 语义相似度阈值（确保意思相近）
if sim >= 0.80:
# 构建评分：相似度×差异度，在保持语义的前提下选择差异最大的
score = sim * diff
valid_candidates.append((candidates[i], score))
# 按评分排序并返回最佳候选
if valid_candidates:
valid_candidates.sort(key=lambda x: x[1], reverse=True)
return valid_candidates[0][0]
except ImportError as e:
logger.warning(f"融合改写依赖库缺失: {e}，将使用基础改写")
except Exception as e:
logger.error(f"融合改写处理错误: {e}")
# 如果融合处理失败，返回第一个候选或原句
return candidates[0] if candidates else original该技术的核心优势在于:
系统提供多种处理模式，用户可在GUI界面选择。模式定义在constants.py中：
# 处理模式定义
PROCESSING_MODES = {
"NORMAL": {
"description": "基础处理模式，仅使用本地资源",
"requires_api": False,
"features": ["local_synonyms", "basic_patterns"]
},
"ADVANCED": {
"description": "高级处理模式，结合API增强",
"requires_api": True,
"features": ["local_synonyms", "api_synonyms", "sentence_rewrite", "fusion_optional"]
}
}
处理模式的实现在core.py/TextProcessor类中，决定了整个处理流程的行为。不同模式下系统会启用不同的功能组件，特别是在高级模式下，系统将使用API驱动的深度改写功能。
系统实现了三级策略强度控制，影响替换率、改写概率和处理深度：
# 处理策略定义
STRATEGY_LEVELS = {
"LIGHT": {
"description": "轻度处理，保守修改",
"synonym_replace_rate": 0.15, # 同义词替换率
"pattern_apply_rate": 0.25, # 句式模板应用率
"rewrite_probability": 0.25, # 句子改写概率
"temperature": 0.5 # API创造性参数
},
"MODERATE": {
"description": "中度处理，平衡修改",
"synonym_replace_rate": 0.30,
"pattern_apply_rate": 0.50,
"rewrite_probability": 0.50,
"temperature": 0.7
},
"AGGRESSIVE": {
"description": "强度处理，大胆修改",
"synonym_replace_rate": 0.45,
"pattern_apply_rate": 0.80,
"rewrite_probability": 0.75,
"temperature": 0.9
}
}这些策略参数在文本处理的各个环节被应用，使系统能够根据用户需求，在保守处理与激进改写之间找到平衡点。例如，在"LIGHT"策略下，系统会最小化对原文的修改，而在"AGGRESSIVE"策略下，则会进行更广泛的替换和改写。
系统提供多种预设改写风格，通过向API发送不同的提示模板实现：
# 改写风格定义
REWRITE_STYLES = {
"default": {
"name": "默认",
"description": "平衡的改写",
"prompt": "请改写以下句子，保持原意但使用不同的表达方式:"
},
"formal": {
"name": "正式学术",
"description": "更正式、学术化的表达",
"prompt": "请将以下句子改写为更正式、学术化的表达，保持原意:"
},
"casual": {
"name": "自然口语",
"description": "更自然、口语化的表达",
"prompt": "请将以下句子改写为更口语化、自然的表达，保持原意:"
},
"complex": {
"name": "增加复杂度",
"description": "使用更丰富的词汇和复杂句式",
"prompt": "请将以下句子改写为更复杂、词汇丰富的表达，保持原意:"
},
"simple": {
"name": "降低复杂度",
"description": "使用更简洁明了的表达",
"prompt": "请将以下句子改写为更简洁、清晰的表达，保持原意:"
}
}不同的改写风格在保持原文意义的同时，会产生不同的语言特征，帮助用户根据目标读者和应用场景定制文本风格。例如，学术论文可能倾向于使用"正式学术"风格，而博客文章可能更适合"自然口语"风格。
为提高处理大型文档的效率，系统实现了基于多线程的并发处理框架，特别是在处理大段落和多文件时性能显著提升：
# 多线程并发处理
def process_file_with_concurrency(input_file, output_file, processor, max_workers=4):
"""使用多线程并发处理文件
Args:
input_file: 输入文件路径
output_file: 输出文件路径
processor: TextProcessor实例
max_workers: 最大工作线程数
Returns:
tuple: (成功标志, 处理后内容, 原始内容)
"""
# 读取文件内容
content = read_file(input_file)
if not content:
return False, None, None
# 按段落分割
paragraphs = split_into_paragraphs(content)
processed_paragraphs = [None] * len(paragraphs)
# 创建进度条
with tqdm(total=len(paragraphs), desc="处理进度") as pbar:
# 定义处理函数
def process_paragraph_task(idx):
try:
para = paragraphs[idx]
processed = asyncio.run(processor.process_text(para))
processed_paragraphs[idx] = processed
pbar.update(1)
return True
except Exception as e:
logger.error(f"处理段落 {idx} 时出错: {e}")
processed_paragraphs[idx] = paragraphs[idx] # 出错时保留原段落
pbar.update(1)
return False
# 使用线程池并发处理
with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
futures = [executor.submit(process_paragraph_task, i)
for i in range(len(paragraphs))]
concurrent.futures.wait(futures)
# 重组文本
result_content = "".join(processed_paragraphs)
# 写入输出文件
if result_content:
write_file(output_file, result_content)
return True, result_content, content
return False, None, content并发处理模块的关键特性包括：
系统实现了完善的API调用管理机制，处理网络波动、服务限制和错误恢复：
async def call_api_with_retry(api_key, prompt, max_retries=3,
initial_timeout=10, model="gemini-pro", **kwargs):
"""带有重试机制的API调用
Args:
api_key: API密钥
prompt: 请求提示词
max_retries: 最大重试次数
initial_timeout: 初始超时时间(秒)
model: 使用的模型名称
**kwargs: 额外参数
Returns:
API响应文本或None(失败时)
"""
retry_count = 0
timeout = initial_timeout
models = [model] # 主模型
# 如果主模型不是默认模型，添加默认模型作为备选
if model != "gemini-pro":
models.append("gemini-pro")
# 如果配置了模型轮换列表，使用它
model_rotation = kwargs.get("model_rotation", [])
if model_rotation:
models.extend([m for m in model_rotation if m not in models])
# 移除重复模型
models = list(dict.fromkeys(models))
# 遍历所有可用模型
for current_model in models:
retry_count = 0
while retry_count < max_retries:
try:
# 使用当前模型调用API
response = await call_api_directly(
api_key=api_key,
model=current_model,
prompt=prompt,
timeout=timeout,
**kwargs
)
if response:
return response
except ApiRateLimitError:
# 速率限制错误，增加等待时间
wait_time = 2 ** retry_count
logger.warning(f"API速率限制，等待{wait_time}秒后重试")
await asyncio.sleep(wait_time)
except ApiTimeoutError:
# 超时错误，增加超时时间
timeout = timeout * 1.5
logger.warning(f"API超时，增加超时至{timeout}秒")
except ApiAuthError:
# 认证错误，无需重试
logger.error(f"API认证错误，密钥可能无效: {api_key[:5]}...")
break
except Exception as e:
# 其他错误
logger.error(f"API调用错误({current_model}): {str(e)}")
retry_count += 1
# 指数退避策略
await asyncio.sleep(min(2 ** retry_count, 30))
# 所有模型和重试都失败
return None这种设计确保了系统在网络条件不稳定时仍能正常工作，并通过智能重试和模型切换提高整体成功率。
本项目采用模块化的设计思路，主要由以下几个核心组件构成：
gui.py 实现，基于 Python 内置的 Tkinter 库。file_processor.py 实现。负责文件读写、备份、多线程任务调度。core.py 中的 TextProcessor 类实现。封装核心算法（语言检测、分割、保护、替换、改写、融合）。text_processor.py 提供。底层文本操作（分词、数据加载）。api_client.py 实现。封装与 LLM API 的异步交互（请求、重试、模型切换）。config_manager.py 实现。安全加载/保存配置（特别是加密 API 密钥）。constants.py 定义常量；data/ 目录存放 JSON 数据文件。utils.py 提供，如日志配置。sentence-transformers, python-Levenshtein 用于融合改写；模型缓存在 ~/.anti_ai_detector/model_cache/。以下是项目关键文件和目录的说明：
.
├── anti_ai_detector/ # 核心 Python 包目录
│ ├── __init__.py # 包初始化文件
│ ├── api_client.py # API 客户端 (异步请求, 重试, 模型切换)
│ ├── config_manager.py # 配置管理 (密钥加密存储)
│ ├── constants.py # 全局常量 (路径, 模式, 策略, 正则, 模型列表)
│ ├── core.py # 核心处理引擎 (TextProcessor, 替换, 改写, 融合)
│ ├── file_processor.py # 文件读写 (txt, docx), 多线程调度
│ ├── gui.py # 图形用户界面 (Tkinter)
│ ├── main.py # (可能存在) GUI 应用程序的另一种入口点
│ ├── text_processor.py # 底层文本工具 (分词, 数据加载)
│ └── utils.py # 通用工具 (日志配置)
├── data/ # 存放数据文件 (若不存在，建议创建或由程序生成)
│ ├── synonyms_cn.json # 中文同义词库
│ ├── synonyms_en.json # 英文同义词库
│ ├── sentence_patterns.json # 句式转换模板
│ └── protected_terms.json # 用户自定义保护词列表
├── .anti_ai_detector/ # (位于用户主目录) 缓存目录 (需程序运行时创建)
│ └── model_cache/ # 用于缓存 sentence-transformers 模型
├── __pycache__/ # Python 字节码缓存 (自动生成)
├── requirements.txt # Python 依赖库列表 (含可选库)
├── run.py # 项目启动脚本 (推荐)
├── project_documentation.html # 本项目文档文件
├── text_processor.log # 程序运行日志文件
└── README.md # 项目的 Markdown 格式简要说明
注意: data/ 目录及其内容可能需要手动创建或由程序首次运行时生成。.anti_ai_detector/ 目录位于用户主目录下，由程序自动创建用于缓存。
pip --version检查，python -m pip install --upgrade pip升级）requirements.txt文件的完整内容:
# 核心依赖
nltk>=3.7.0 # 自然语言处理工具包，用于分词和语句划分
python-docx>=0.8.11 # 用于处理.docx格式文件
cryptography>=38.0.0 # 用于API密钥的加密存储
aiohttp>=3.8.1 # 异步HTTP客户端，用于API调用
tqdm>=4.64.0 # 进度条显示
langdetect>=1.0.9 # 语言检测
regex>=2022.3.15 # 增强的正则表达式支持
# 可选但推荐（融合改写相关）
sentence-transformers>=2.2.2 # 用于语义相似度计算
python-Levenshtein>=0.20.0 # 用于计算编辑距离
torch>=1.11.0 # PyTorch，sentence-transformers的依赖
transformers>=4.18.0 # Hugging Face Transformers库
# 代理支持（可选）
pysocks>=1.7.1 # SOCKS代理支持
pip install -r requirements.txtpip install nltk python-docx cryptography aiohttp tqdm langdetect regexpip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple# CUDA支持（NVIDIA显卡用户）
pip install torch==1.13.1+cu117 -f https://download.pytorch.org/whl/torch_stable.html
# 或ROCm支持（AMD显卡用户）
pip install torch==1.13.1 -f https://download.pytorch.org/whl/rocm5.2/torch_stable.htmlimport nltk
nltk.download('punkt')
nltk.download('averaged_perceptron_tagger') # 可选，用于词性标注
nltk.download('wordnet') # 可选，用于同义词查找all-MiniLM-L6-v2，约90MB）至本地缓存目录~/.anti_ai_detector/model_cache/（Windows下为%USERPROFILE%\.anti_ai_detector\model_cache\）。~/.anti_ai_detector/model_cache/all-MiniLM-L6-v2/data/目录创建必要的数据文件：
synonyms_cn.json：中文同义词库（约5MB）synonyms_en.json：英文同义词库（约3MB）sentence_patterns.json：句式转换模板（约200KB）protected_terms.json：用户自定义保护词列表（初始为空）在项目根目录，通过终端运行：
python run.py启动时留意终端提示信息。
(GUI 截图占位符)
~/.anti_ai_detector/config/settings.enc (或类似路径)。~/.anti_ai_detector/model_cache/。data/ 下的 JSON 文件。constants.py。答：API 密钥用于访问外部的大语言模型服务。这些服务用于执行高质量的同义词替换（可选）和复杂的句子改写（包括"融合改写"）。没有 API 密钥，您仍然可以使用 `NORMAL` 模式，它仅依赖本地词库和句式模板，但降 AI 检测率的效果可能有限，且无法使用"融合改写"等高级功能。
答：不能保证。AI 检测技术在不断发展，没有一种方法能绝对保证绕过所有检测。本工具旨在通过模拟人类写作特征来显著 *降低* 被检测为 AI 生成内容的 *概率*。最终效果取决于多种因素。强烈建议将处理后的文本作为初稿，进行人工审阅和修改。
答：这可能是因为处理策略过于激进，或某些替换/改写与上下文不太匹配。建议：1. 降低处理策略强度（如 `MODERATE` 或 `LIGHT`）。2. 尝试不同的"改写风格"。3. 禁用"融合改写"看是否改善。4. 添加更多"保护词"。5. **最重要：进行人工审阅和润色。**
答："融合改写"是一种更高级的句子改写策略。它会请求 API 生成多个候选改写版本，然后通过比较语义相似度和表达差异度，选出那个在保持原意的基础上，与原句表达方式差异最大的版本。目标是引入更多变化，进一步降低被模式化检测的风险。它需要额外的库 (sentence-transformers, python-Levenshtein) 和对应的模型，且依赖 API 调用。
答：这通常与 sentence-transformers 模型有关。请检查：
1. **依赖安装**：确保 requirements.txt 中的所有库都已成功安装。
2. **模型下载**：首次使用需要下载模型。如果网络不佳导致下载失败，请参考用户手册中的"模型下载说明"进行手动下载或配置网络环境。
3. **缓存问题**：如果之前下载不完整，尝试删除缓存目录 (~/.anti_ai_detector/model_cache/) 下的模型文件，然后重试。
4. **网络连接**：确认您的网络可以访问 Hugging Face (模型下载源) 和您配置的 LLM API 服务。
答：在 GUI 界面的"保护词管理"区域输入术语并点击"添加"。或直接编辑项目根目录下的 data/protected_terms.json 文件。
答：处理速度受文件大小、选择的模式/策略（API 调用很耗时）、线程数、CPU 及网络状况影响。尝试：1. 适当调整"线程数量"。2. 使用 `NORMAL` 模式。3. 确保网络稳定。4. 耐心等待。
程序使用多线程处理来提高性能。以下是优化建议：
# 示例：优化内存配置
from anti_ai_detector.config_manager import ConfigManager
config = ConfigManager()
config.set_memory_config({
'chunk_size': 1024 * 1024, # 1MB chunks
'max_workers': 8, # 线程数
'batch_size': 10 # 批处理大小
})
# 示例：配置模型缓存
from anti_ai_detector.core import TextProcessor
processor = TextProcessor()
processor.set_cache_config({
'cache_dir': '~/.anti_ai_detector/model_cache',
'max_cache_size': '2GB',
'cache_ttl': 30 # 天
})
# 示例：配置API客户端
from anti_ai_detector.api_client import ApiClient
client = ApiClient()
client.configure({
'timeout': 30,
'max_retries': 3,
'backoff_factor': 1.5,
'concurrent_requests': 5
})
程序使用加密存储保护API密钥：
# 示例：安全存储API密钥
from anti_ai_detector.config_manager import ConfigManager
config = ConfigManager()
config.set_api_key('your-api-key', encrypt=True)
# 密钥使用AES-256加密存储在配置文件中
# 示例：配置访问控制
from anti_ai_detector.utils import SecurityManager
security = SecurityManager()
security.set_permissions({
'allow_external_scripts': False,
'allow_file_system_access': True,
'allowed_paths': ['data/', 'output/']
})
# 示例：配置详细日志
import logging
logging.basicConfig(
filename='debug.log',
level=logging.DEBUG,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
本系统的版本更新记录，用于追踪功能演进和重要变更。