1. 项目概述：为什么用机器学习做查重？

在内容创作、学术研究和教育领域，原创性检查一直是个核心痛点。传统的查重工具，无论是基于字符串精确匹配的本地软件，还是依赖庞大数据库的在线服务，都存在明显的局限性。前者对改写、同义词替换几乎无能为力，后者则严重受限于数据库的覆盖范围，且往往无法处理非文本（如代码、公式）或特定领域的专业内容。

这正是“用机器学习构建一个查重工具”这个项目吸引我的地方。它不是一个简单的工具复现，而是一次从底层原理出发，重新思考“相似性”定义的实践。我们不再仅仅比较字符是否相同，而是试图让机器理解文本的“语义”，从而识别出那些经过精心改写、但核心思想雷同的抄袭行为。这个项目适合有一定Python和机器学习基础，并对自然语言处理（NLP）感兴趣的朋友。通过它，你不仅能亲手搭建一个可用的工具，更能深入理解文本表示、相似度计算和模型部署的完整链路。

2. 核心思路与技术选型

构建一个ML驱动的查重器，核心思路可以概括为： 将文本转化为机器可理解的数值向量（嵌入），然后计算这些向量之间的距离，以此量化文本间的相似度 。听起来简单，但每一步都充满了技术选型的考量。

2.1 整体架构设计

一个完整的查重系统通常包含以下模块：

1. 文本预处理模块 ：负责清洗和标准化输入的文本。
2. 特征提取/文本表示模块 ：这是核心，将文本转化为向量。
3. 相似度计算模块 ：计算向量之间的距离或相似度得分。
4. 结果判定与输出模块 ：根据阈值判断是否抄袭，并生成报告。

我们的重点和难点集中在第2和第3步。

2.2 文本表示方案选型

如何把一段文字变成一串有意义的数字？这里有几种主流方案，各有优劣：

方案一：基于词频的统计方法（如TF-IDF）

• 原理 ：将文档表示为一个高维向量，每个维度对应一个词，值是该词的TF-IDF权重（词频-逆文档频率）。它衡量了一个词在当前文档中的重要程度。
• 优点 ：实现简单，计算速度快，无需训练数据，对字面重复敏感。
• 缺点 ：完全无法理解语义。“苹果公司”和“Apple Inc.”会被视为毫不相干。向量维度高且稀疏。
• 适用场景 ：对速度要求极高、且主要检测直接复制粘贴的场景。

方案二：基于词向量的平均（如Word2Vec, GloVe）

• 原理 ：使用预训练模型（如Google的Word2Vec或斯坦福的GloVe）将每个词映射为一个稠密向量（例如300维），然后将文档中所有词的向量取平均，得到文档向量。
• 优点 ：一定程度上考虑了语义，因为预训练模型从海量数据中学到了词的语义关系（例如“国王”-“男人”+“女人”≈“女王”）。比TF-IDF向量更稠密、维度更低。
• 缺点 ：简单的平均操作会丢失词序信息，而词序对语义至关重要。“狗咬人”和“人咬狗”的平均向量可能是一样的。对未登录词（OOV）处理不佳。

方案三：基于上下文的深度模型（如BERT, Sentence-BERT）

• 原理 ：使用Transformer架构的预训练模型（如BERT），它能够根据词的上下文生成动态的词向量。对于句子/文档级表示，通常取[CLS]标记的输出向量，或对所有词向量进行池化（如均值池化）。Sentence-BERT（SBERT）更是专门为句子相似度任务微调过的模型。
• 优点 ：强大的语义理解能力，能有效处理同义词替换、句式变换、甚至一定程度的逻辑推理。是目前语义相似度任务的SOTA（state-of-the-art）方案。
• 缺点 ：计算资源消耗大（尤其是长文本），推理速度慢，模型体积庞大。需要一定的硬件支持。

我们的选择与理由 ： 对于教学和入门项目，我推荐从 方案二（GloVe词向量平均） 开始。它在语义理解、实现难度和计算成本之间取得了很好的平衡。当你需要更高精度时，可以平滑过渡到 方案三（SBERT） 。本项目将主要讲解基于GloVe的实现，并在关键部分对比SBERT的方案。

2.3 相似度度量方法

得到两个文档向量A和B后，如何计算相似度？常用方法有：

• 余弦相似度 ：最常用。计算两个向量夹角的余弦值，范围[-1,1]，值越大越相似。它对向量的绝对长度不敏感，只关注方向，非常适合文本相似度比较。
• 欧氏距离 ：计算向量间的直线距离。距离越小越相似。有时会对距离进行转换（如 1 / (1 + distance) ）得到相似度分数。
• 曼哈顿距离 ：较少用于文本。

我们的选择 ： 余弦相似度 。它是文本相似度计算的事实标准，直观且有效。

3. 实战构建：基于GloVe的查重器

下面，我们一步步实现一个基于GloVe词向量和余弦相似度的基础版查重器。

3.1 环境准备与依赖安装

首先，确保你的Python环境（建议3.8以上）并安装必要的库。我们将使用 numpy 进行向量计算， scikit-learn 用于余弦相似度， nltk 或 spacy 进行文本预处理。

pip install numpy scikit-learn nltk

然后，我们需要下载GloVe预训练词向量。这里我们使用较小的 glove.6B.100d.txt （6B tokens, 100维），从斯坦福官网下载。

import requests
import zipfile
import os

# 下载GloVe预训练向量 (文件较大，约800MB)
glove_url = "http://nlp.stanford.edu/data/glove.6B.zip"
glove_zip_path = "glove.6B.zip"
glove_extract_path = "."

if not os.path.exists(glove_zip_path):
    print("正在下载GloVe词向量...")
    response = requests.get(glove_url, stream=True)
    with open(glove_zip_path, 'wb') as f:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)
    print("下载完成。")

# 解压（我们只需要100维的版本）
if not os.path.exists(os.path.join(glove_extract_path, "glove.6B.100d.txt")):
    print("正在解压...")
    with zipfile.ZipFile(glove_zip_path, 'r') as zip_ref:
        # 只解压我们需要的文件，节省空间
        zip_ref.extract("glove.6B.100d.txt", path=glove_extract_path)
    print("解压完成。")

3.2 文本预处理模块实现

干净的文本是准确向量的前提。预处理步骤通常包括：

1. 转换为小写
2. 移除标点符号、特殊字符
3. 分词
4. 移除停用词（如“the”, “is”, “in”）
5. 词干化或词形还原（可选，能提升效果但增加复杂度）

import re
import nltk
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
# 首次运行需要下载nltk数据
nltk.download('punkt')
nltk.download('stopwords')

def preprocess_text(text):
    """
    对输入文本进行预处理。
    """
    # 1. 转为小写
    text = text.lower()
    # 2. 移除标点、数字和特殊字符（保留字母和空格）
    text = re.sub(r'[^a-z\s]', '', text)
    # 3. 分词
    words = word_tokenize(text)
    # 4. 移除停用词
    stop_words = set(stopwords.words('english'))
    words = [w for w in words if w not in stop_words]
    # 5. 可选：词干化 (这里使用PorterStemmer)
    # from nltk.stem import PorterStemmer
    # stemmer = PorterStemmer()
    # words = [stemmer.stem(w) for w in words]
    return words

# 示例
sample_text = "The quick brown fox jumps over the lazy dog. It's a classic sentence!"
print(preprocess_text(sample_text))
# 输出: ['quick', 'brown', 'fox', 'jumps', 'lazy', 'dog', 'classic', 'sentence']

注意 ：预处理策略需要根据你的查重目标调整。例如，在检测代码抄袭时，标点、大小写可能很重要，就不能简单移除。对于学术论文，停用词列表可能需要自定义，避免移除关键术语。

3.3 加载GloVe词向量并构建文档向量

这是核心步骤。我们将预训练的GloVe词向量加载到一个字典中，然后通过平均文档中所有有效词的向量来得到文档向量。

import numpy as np

def load_glove_model(glove_file_path):
    """
    加载GloVe词向量文件到字典。
    格式: word v1 v2 ... vd
    """
    print("正在加载GloVe模型...")
    glove_model = {}
    with open(glove_file_path, 'r', encoding='utf-8') as f:
        for line in f:
            split_line = line.split()
            word = split_line[0]
            embedding = np.array([float(val) for val in split_line[1:]])
            glove_model[word] = embedding
    print(f"加载完成，共 {len(glove_model)} 个词向量。")
    return glove_model

def document_to_vector(words, glove_model, vector_size=100):
    """
    将分词后的文档词列表转换为一个文档向量（取平均）。
    """
    vector = np.zeros(vector_size)
    word_count = 0
    for word in words:
        if word in glove_model:
            vector += glove_model[word]
            word_count += 1
    if word_count > 0:
        vector /= word_count  # 平均
    # 如果文档中没有任何词在GloVe词汇表中，返回零向量
    return vector

# 加载模型
glove_path = "./glove.6B.100d.txt"
glove_model = load_glove_model(glove_path)

# 示例：将两段文本转化为向量
text1 = "Machine learning is a subset of artificial intelligence."
text2 = "AI includes machine learning as a key component."

words1 = preprocess_text(text1)
words2 = preprocess_text(text2)

vec1 = document_to_vector(words1, glove_model)
vec2 = document_to_vector(words2, glove_model)

print(f"文本1向量形状: {vec1.shape}")
print(f"文本2向量形状: {vec2.shape}")

3.4 计算相似度与判定抄袭

有了文档向量，计算余弦相似度就很简单了。我们还需要设定一个阈值来判断是否构成抄袭。

from sklearn.metrics.pairwise import cosine_similarity

def calculate_cosine_similarity(vec1, vec2):
    """
    计算两个向量间的余弦相似度。
    """
    # 确保向量是二维的（样本数，特征数）
    vec1 = vec1.reshape(1, -1)
    vec2 = vec2.reshape(1, -1)
    return cosine_similarity(vec1, vec2)[0][0]

def check_plagiarism(text_a, text_b, glove_model, threshold=0.8):
    """
    主函数：检查两段文本的相似度。
    """
    # 预处理
    words_a = preprocess_text(text_a)
    words_b = preprocess_text(text_b)
    # 转为向量
    vec_a = document_to_vector(words_a, glove_model)
    vec_b = document_to_vector(words_b, glove_model)
    # 计算相似度
    similarity = calculate_cosine_similarity(vec_a, vec_b)
    # 判定
    is_plagiarized = similarity >= threshold
    return similarity, is_plagiarized

# 测试
doc_a = "The theory of relativity revolutionized physics."
doc_b = "Physics was transformed by Einstein's theory of relativity." # 同义改写
doc_c = "Apple is a famous technology company headquartered in Cupertino."

sim_ab, result_ab = check_plagiarism(doc_a, doc_b, glove_model, 0.7)
sim_ac, result_ac = check_plagiarism(doc_a, doc_c, glove_model, 0.7)

print(f"文档A与B相似度: {sim_ab:.4f}, 是否抄袭: {result_ab}")
print(f"文档A与C相似度: {sim_ac:.4f}, 是否抄袭: {result_ac}")

运行上述代码，你会发现即使文档A和B用了不同的句式（主动/被动）和词汇（revolutionized/transformed），基于GloVe的模型也能给出较高的相似度分数（可能在0.6-0.9之间，取决于具体词汇），而A和C的相似度会很低。这初步验证了我们模型对语义的理解能力。

4. 进阶优化与方案对比

基础版已经能工作，但离“好用”还有距离。以下是几个关键的优化方向。

4.1 使用Sentence-BERT（SBERT）提升精度

当GloVe平均向量的效果达不到要求时，SBERT是下一个台阶。它通过孪生网络结构对句子进行编码，产生的向量在语义相似度任务上表现极佳。

# 安装 sentence-transformers
# pip install sentence-transformers

from sentence_transformers import SentenceTransformer, util

def check_plagiarism_sbert(text_a, text_b, threshold=0.8):
    """
    使用SBERT检查抄袭。
    """
    # 加载预训练模型，这里使用轻量级的'all-MiniLM-L6-v2'
    model = SentenceTransformer('all-MiniLM-L6-v2')
    # 编码句子
    embedding_a = model.encode(text_a, convert_to_tensor=True)
    embedding_b = model.encode(text_b, convert_to_tensor=True)
    # 计算余弦相似度
    similarity = util.cos_sim(embedding_a, embedding_b).item()
    is_plagiarized = similarity >= threshold
    return similarity, is_plagiarized

# 测试SBERT
sim_sbert, res_sbert = check_plagiarism_sbert(doc_a, doc_b, 0.7)
print(f"[SBERT] 文档A与B相似度: {sim_sbert:.4f}, 是否抄袭: {res_sbert}")

GloVe平均 vs SBERT 实测对比 ：

• 语义理解 ：SBERT显著优于GloVe平均。对于复杂的句式变换和抽象概念匹配，SBERT更可靠。
• 速度 ：GloVe平均（加载模型后）极快，适合实时或大批量处理。SBERT编码稍慢，但得益于Transformer优化，在GPU上也能接受。
• 资源 ：GloVe模型约几百MB。SBERT模型（如 all-MiniLM-L6-v2 ）约80MB，但运行时需要更多内存。
• 长文本 ：两者都面临长文本问题。GloVe平均会稀释关键信息。SBERT有最大长度限制（如512个token），处理长文档需要分段或使用长文本模型（如 all-mpnet-base-v2 配合滑动窗口）。

选型建议 ：

• 追求速度和简单 ：选GloVe平均。
• 追求精度和语义理解 ：选SBERT。
• 处理长文档（如论文） ：需要将文档按段落或固定长度切分，分别计算相似度，再综合判断（如取最高相似度段落对，或加权平均）。

4.2 处理长文档与设定动态阈值

单篇文档可能很长，直接编码会丢失信息。标准做法是进行 分块（Chunking） 。

def split_into_chunks(text, chunk_size=200, overlap=50):
    """
    将长文本分割成有重叠的块。
    chunk_size: 每个块的单词数
    overlap: 块之间的重叠单词数
    """
    words = text.split() # 简单按空格分词，可根据需要替换为更精细的分词器
    chunks = []
    for i in range(0, len(words), chunk_size - overlap):
        chunk = ' '.join(words[i:i + chunk_size])
        chunks.append(chunk)
        if i + chunk_size >= len(words):
            break
    return chunks

def check_long_document_plagiarism(doc_a, doc_b, model_type='glove', threshold=0.7):
    """
    检查长文档抄袭，采用分块-最大相似度策略。
    """
    if model_type == 'glove':
        # 使用之前的GloVe函数，需要传入glove_model
        # 这里省略glove_model参数传递细节
        encoder_func = lambda t: document_to_vector(preprocess_text(t), glove_model)
        sim_func = calculate_cosine_similarity
    else: # sbert
        sbert_model = SentenceTransformer('all-MiniLM-L6-v2')
        encoder_func = lambda t: sbert_model.encode(t, convert_to_tensor=False) # 返回numpy数组
        sim_func = cosine_similarity # 使用sklearn的

    chunks_a = split_into_chunks(doc_a)
    chunks_b = split_into_chunks(doc_b)

    max_similarity = 0.0
    for ca in chunks_a:
        vec_a = encoder_func(ca).reshape(1, -1)
        for cb in chunks_b:
            vec_b = encoder_func(cb).reshape(1, -1)
            sim = sim_func(vec_a, vec_b)[0][0]
            if sim > max_similarity:
                max_similarity = sim

    return max_similarity, max_similarity >= threshold

阈值设定是一门艺术 ，没有通用值。它取决于：

1. 文本领域 ：技术报告阈值可能设高（如0.85），因为专业术语重合率高；创意写作阈值设低（如0.65）。
2. 模型选择 ：SBERT产生的相似度分数分布可能与GloVe不同，需要重新校准。
3. 分块大小 ：块越小，越容易捕捉局部抄袭，但也可能因噪声导致分数偏高。

建议做法 ：在你自己领域的文本上，人工标注一批“抄袭”和“非抄袭”的样本对，运行模型得到相似度分数分布图，根据分布选择一个能平衡查准率（Precision）和查全率（Recall）的阈值。

4.3 构建本地文本库与批量比对

真正的查重系统需要比对海量文档。我们需要构建一个 向量数据库 。

1. 建立索引 ：将你的参考文档库（如以往的学生论文、网络文章）全部预处理并转化为向量，存储起来。
2. 快速检索 ：当有新文档需要查重时，将其转化为向量，然后使用 近似最近邻搜索（ANN） 算法（如Faiss, Annoy, ScaNN）快速从向量库中找到最相似的Top-K个文档。
3. 结果聚合 ：与Top-K个候选文档逐一计算精确相似度，给出最高分和来源。

# 使用Faiss进行高效向量检索的示例框架
# pip install faiss-cpu

import faiss
import numpy as np

class VectorDatabase:
    def __init__(self, dimension):
        self.dimension = dimension
        self.index = faiss.IndexFlatL2(dimension) # 使用L2距离，也可以使用内积（需归一化）
        self.documents = [] # 存储对应的文档ID或内容

    def add_vectors(self, vectors, doc_ids):
        """ 添加向量到数据库 """
        vectors = np.array(vectors).astype('float32')
        self.index.add(vectors)
        self.documents.extend(doc_ids)

    def search(self, query_vector, k=5):
        """ 搜索最相似的k个文档 """
        query_vector = np.array([query_vector]).astype('float32')
        distances, indices = self.index.search(query_vector, k)
        # 将距离转换为相似度（假设使用L2距离，相似度 = 1 / (1 + distance)）
        similarities = 1 / (1 + distances[0])
        results = [(self.documents[idx], sim) for idx, sim in zip(indices[0], similarities)]
        return results

# 使用示例
dim = 100 # GloVe向量维度
db = VectorDatabase(dim)
# 假设doc_vectors是参考库所有文档的向量列表，doc_ids是对应的ID列表
# db.add_vectors(doc_vectors, doc_ids)

# 查询新文档
# query_vec = document_to_vector(preprocess_text(new_doc), glove_model)
# top_matches = db.search(query_vec, k=10)
# for doc_id, sim in top_matches:
#     if sim > threshold:
#         print(f"疑似抄袭文档 {doc_id}, 相似度: {sim:.4f}")

5. 常见问题、调优与避坑指南

在实际操作中，你会遇到各种各样的问题。以下是我踩过坑后总结的经验。

5.1 相似度分数不理想或波动大

• 问题 ：同样的文本对，每次运行分数有细微差别？或者分数普遍偏低/偏高。
• 排查 ：
  1. 预处理不一致 ：确保预处理流程（如停用词列表、词干化器）完全一致。特别是停用词列表，不同版本或语言的NLTK可能有差异。
  2. OOV问题 ：文档中大量词汇不在GloVe词汇表中，导致有效词少，向量质量差。使用 print(word_count) 检查。对于专业领域，考虑使用领域语料训练的Word2Vec或FastText模型。
  3. 向量归一化 ：计算余弦相似度前， 强烈建议对文档向量进行L2归一化 。这能确保向量模长为1，余弦相似度计算更稳定。 vec = vec / np.linalg.norm(vec) 。
  4. SBERT模型选择 ：不同的SBERT模型适用于不同任务。 all-MiniLM-L6-v2 是速度和效果的平衡。对于精度要求更高，可选 all-mpnet-base-v2 。在 Sentence-Transformers文档 查看模型推荐。

5.2 处理速度太慢

• 问题 ：比对大量文档时耗时过长。
• 优化 ：
  1. 向量化与批处理 ：避免在循环中单条编码。对于SBERT，使用 model.encode(list_of_texts, batch_size=32) 进行批量编码，效率提升巨大。
  2. 启用GPU ：如果使用SBERT或类似深度学习模型，确保安装了对应版本的PyTorch/TensorFlow并启用CUDA。 model = SentenceTransformer('model_name', device='cuda') 。
  3. 使用Faiss GPU索引 ：如果向量库非常大，使用Faiss的GPU索引进行检索。
  4. 缓存 ：对于固定的参考文档库，其向量可以预先计算并持久化存储（如用 numpy.save ），避免每次启动都重新编码。

5.3 判定阈值如何确定

• 问题 ：阈值设为0.7还是0.8？多少算抄袭？
• 方法 ：
  1. 收集测试集 ：至少准备100-200对文本，人工标注好“抄袭”和“非抄袭”。最好覆盖各种抄袭类型（直接复制、改写、观点抄袭等）和不同相似程度。
  2. 绘制PR曲线或ROC曲线 ：在测试集上运行你的查重器，得到所有文本对的相似度分数。然后，遍历不同的阈值（如从0.5到0.95，步长0.05），计算每个阈值下的查准率（Precision）和查全率（Recall）。绘制PR曲线。
  3. 选择平衡点 ：根据你的需求选择阈值。如果要求高查准率（宁可漏检，不可错杀），选择PR曲线上查准率高的点对应的阈值。如果需要高查全率（尽可能抓住所有抄袭，允许一些误报），则选择查全率高的点。通常选择查准率和查全率相对均衡的“拐点”。

5.4 特定领域的适应性问题

• 问题 ：在计算机科学论文上训练的模型，去查重文学评论效果很差。
• 解决方案 ： 领域自适应 。
  1. 使用领域内预训练模型 ：如果能找到你所在领域的预训练词向量或句子模型（如BioWordVec用于生物医学，CodeBERT用于代码），直接使用它们。
  2. 微调SBERT ：这是最有效但需要数据的方法。收集你领域内的文本对（相似/不相似），在SBERT模型基础上进行 有监督对比学习微调 。这能让模型学会你领域内特殊的语义相似性。
  3. 调整预处理 ：领域内的停用词（如文学中的“隐喻”、“象征”可能不是停用词）、分词规则（代码查重需要完全不同的分词器）都需要定制。

5.5 系统部署与API化

当你完成核心算法后，可能需要将其部署为服务。

1. Web框架 ：使用FastAPI或Flask快速构建RESTful API。
2. 异步处理 ：对于长文档查重，使用Celery+Redis等队列进行异步任务处理，避免HTTP请求超时。
3. 模型服务化 ：可以考虑使用TorchServe或TF Serving来单独部署SBERT模型，实现模型加载、版本管理和高效推理。
4. 输入验证与安全 ：API必须对输入文本进行长度限制、字符编码检查，防止DoS攻击或注入攻击。

# 一个简单的FastAPI示例端点
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI()
# 假设已加载好模型和向量数据库
# model = SentenceTransformer('all-MiniLM-L6-v2')
# db = VectorDatabase(...)

class CheckRequest(BaseModel):
    text: str
    reference_id: str = None # 可选，指定与库中某篇对比

@app.post("/check")
async def check_plagiarism(request: CheckRequest):
    try:
        # 1. 编码查询文本
        query_vec = model.encode(request.text)
        # 2. 搜索向量库
        if request.reference_id:
            # 与特定文档对比
            ref_vec = get_vector_by_id(request.reference_id) # 自定义函数
            sim = cosine_similarity([query_vec], [ref_vec])[0][0]
            results = [{"id": request.reference_id, "similarity": sim}]
        else:
            # 与整个库对比
            results = db.search(query_vec, k=10)
        # 3. 过滤和格式化结果
        filtered_results = [{"id": rid, "similarity": float(sim)} for rid, sim in results if sim > THRESHOLD]
        return {"query_text": request.text[:100], "matches": filtered_results}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

构建一个机器学习查重器是一次贯穿数据预处理、模型选型、相似度计算和系统工程的综合实践。从简单的词频统计到深度的语义理解，技术的选择始终围绕着你的具体需求在精度、速度和资源之间做权衡。我个人的体会是，没有“最好”的模型，只有“最合适”的方案。对于大多数应用，从GloVe或TF-IDF基线开始，快速验证想法，再逐步迭代到SBERT等更复杂的模型，是一条稳妥的路径。最关键的一步，永远是准备一批高质量的、贴合你实际场景的测试数据，用它来驱动所有的决策——从阈值设定到模型选型，再到最后的性能评估。