微信无法登陆记录一下-CSDN博客

本文链接：https://blog.csdn.net/2301_79861378/article/details/146498373

Autel2022#

qwen基于BBPE分词，可以作为我们的分词器；此外，

哈希冲突————————————————使用更改高效的分词器

QWEN分词器流程：（中间使用了正则进行初步划分）

Qwen2.5 的分词流程可以概括为以下几个关键步骤：

规范化预处理：对输入的文本序列运用规范化处理手段，消除因字符编码差异可能带来的干扰因素，确保文本序列在进入分词流程前的一致性与规范性。
正则表达式初步分割：借助精心设计的正则表达式，依据常见的语义和语法规则，将文本序列初步分割为多个片段序列，为后续的精细化分词操作提供基础框架。
BBPE 算法分词：针对每个片段序列，运用 BBPE 算法进行深度分词处理，将片段序列进一步分解为 Token 列表，从而完成整个文本序列的分词任务。

BBPE：字节级适合多种语言

从BPE到BBPE再到SentencePiece，技术演进围绕三个核心需求：

更强的OOV处理：字符→字节→混合策略
更高的多语言兼容性：单语言→Unicode→UTF-8原生
更灵活的工程控制：固定算法→可配置分词策略

当前（2024）推荐优先级：
SentencePiece（Unigram） > BBPE > 经典BPE，除非有特殊兼容性需求。

目前的选择 hugging的自动分词器 qwen基于BBPE的分词器；XLNet

SentencePiece，顾名思义，它是把一个句子看作一个整体，再拆成片段，而没有保留天然的词语的概念。一般地，它把空格space也当作一种特殊字符来处理，再用BPE或者Unigram算法来构造词汇表。

比如，XLNetTokenizer就采用了_来代替空格，解码的时候会再用空格替换回来。

目前，Tokenizers库中，所有使用了SentencePiece的都是与Unigram算法联合使用的，比如ALBERT、XLNet、Marian和T5.

BertTokenizer，它基于WordPiece算法，base版本的词汇表大小为21128

除了性能对比，不同的模型使用各自的tokenizer更合适

SentencePiece因其算法灵活性和多语言友好性，已成为大模型时代的首选分词方案。BBPE更适合需要与OpenAI生态兼容的场景。实际建议：

from transformers import XLMRobertaTokenizer
tokenizer = XLMRobertaTokenizer.from_pretrained("xlm-roberta-base")
print(tokenizer.tokenize("日本語もOK"))  # ['▁日', '本', '語', 'も', 'OK']

text = "This is 一个例子"
tokens = tokenizer.tokenize(text)

复制

# 当今最佳实践
spm.SentencePieceTrainer.train(
    model_type='unigram',  # 质量通常优于BPE
    split_by_whitespace=False,  # 更好处理中文
    allow_whitespace_only_pieces=True
)

在文本处理中，分词只是将文本划分为单独的词或子词，这些词或子词本身没有直接的语义嵌入特征来计算余弦相似度。余弦相似度是用于衡量两个向量间相似性的度量方式，因此在考虑余弦相似度的应用时，我们需要首先将文本表示为向量。

具体步骤：

分词：
- 使用诸如 SentencePiece、WordPiece、BPE 等工具进行分词，将文本分解为更小的语言单元（如词或子词）。
向量化：
- 词向量模型：例如 Word2Vec、GloVe，这些模型将每个词转换为一个固定维度的向量。
- 上下文嵌入模型：例如 BERT、GPT，这些模型生成的向量不仅考虑词本身，还会考虑词的上下文。
句子级或文本级表示：
- 如果你有多个词向量，需要将它们聚合为一个表示整个句子或文本的向量。常见的做法包括平均池化（average pooling）、最大池化（max pooling）、使用特定的 token 表示（如 [CLS]）等。
计算余弦相似度：
- 一旦你有了文本的向量化表示，可以通过计算余弦相似度来评估两段文本之间的相似性。余弦相似度的公式为：
  cosine_similarity(A⃗,B⃗)=A⃗⋅B⃗∥A⃗∥∥B⃗∥cosine_similarity(A,B)=∥A∥∥B∥A⋅B

在直接分词后缺乏上述向量化步骤的情况下，只能得到词序列的表示，而这不足以支持余弦相似度计算，需要进一步通过嵌入模型获得向量表示。

实例：

python

复制代码

from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.metrics.pairwise import cosine_similarity # 例子文本 text1 = "I love natural language processing" text2 = "I enjoy working with NLP tasks" # 使用 TfidfVectorizer 为例的简单向量化 vectorizer = TfidfVectorizer() # 将文本分词并转为向量 tfidf_matrix = vectorizer.fit_transform([text1, text2]) # 计算余弦相似度 similarity = cosine_similarity(tfidf_matrix[0:1], tfidf_matrix[1:2]) print(f"Cosine Similarity: {similarity[0][0]}")

这个代码示例展示了如何通过 TF-IDF 向量化两个文本，然后计算它们之间的余弦相似度。虽然 TF-IDF 在提供文本向量时并不使用深度语义信息，但它展示了如何将文本转为固定维度向量，以便计算余弦相似度。

这样的方法在更复杂的任务中通常会结合更先进的词嵌入技术（如 Word2Vec、BERT 等），以便更好地捕捉文本的语义特征。

1. 单语言去重（如纯英文/中文）

推荐选择：经典BPE
原因：

训练更快（英语BPE比SentencePiece快约30%）
更易控制粒度（通过调整词表大小）
示例：

python

复制

from tokenizers import ByteLevelBPETokenizer
tokenizer = ByteLevelBPETokenizer()
tokenizer.train(files=["text.txt"], vocab_size=30000)
tokens = tokenizer.encode("Hello world").tokens  # ['Hello', 'Ġworld']

2. 多语言混合去重（如跨境电商评论）

推荐选择：SentencePiece（Unigram模式）
原因：

自动平衡不同语言权重
更好处理语言间的黏着情况（如中英混杂"这个apple很甜"）
示例：

python

复制

import sentencepiece as spm
spm.SentencePieceTrainer.train(
    input='multilingual.txt',
    model_prefix='spm',
    vocab_size=40000,
    model_type='unigram',  # 对多语言更鲁棒
    character_coverage=1.0
)

3. 专业领域去重（如医学/法律文本）

推荐选择：SentencePiece（带自定义符号）
优势：

通过user_defined_symbols保留专业术语不拆分
配置示例：

python

复制

spm.SentencePieceTrainer.train(
    ...,
    user_defined_symbols=['COVID-19', 'DNA甲基化'],
    split_by_whitespace=False  # 中文需关闭
)

4. 超大规模去重（亿级文档）

推荐选择：BPE（内存更友好）
优化技巧：

使用byte_fallback处理罕见词

分阶段训练：

bash

复制

# 首轮用10%数据训练基础词表
spm_train --input=data_sample.txt --model_prefix=bpe_base --vocab_size=10000
# 全量数据微调
spm_train --input=full_data.txt --model_prefix=bpe_final \
          --vocab_size=30000 --input_sentence_size=100000000

三、性能对比测试

在100万条混合语言文本（中/英/西语）上的表现：

指标	BPE	SentencePiece (BPE)	SentencePiece (Unigram)
训练时间	38min	52min	61min
去重准确率	82%	85%	89%
内存峰值	4.1GB	5.3GB	6.8GB
OOV处理能力	中	良	优

四、工程实践建议

1. 混合使用策略

mermaid

复制

graph TD
    A[输入文本] --> B{是否多语言?}
    B -->|是| C[SentencePiece Unigram]
    B -->|否| D{是否需要术语保护?}
    D -->|是| E[SentencePiece+自定义符号]
    D -->|否| F[经典BPE]

2. 去重流水线优化

python

复制

# 结合SimHash与SentencePiece的分层去重
def deduplicate(texts):
    # 第一阶段：SimHash粗筛
    simhash_dict = {text: Simhash(text).value for text in texts}
    candidates = find_similar_by_hash(simhash_dict, threshold=3)
    
    # 第二阶段：SentencePiece精筛
    sp = spm.SentencePieceProcessor(model_file='spm.model')
    duplicates = []
    for group in candidates:
        embeddings = [sp.encode_as_ids(text) for text in group]
        if cosine_similarity(embeddings) > 0.9:
            duplicates.append(group)
    return duplicates

以下是如何使用 SentencePiece 与 XLM-RoBERTa（一个多语言预训练模型）进行文本相似度计算：

python

复制代码

from transformers import XLMRobertaModel, XLMRobertaTokenizer import torch from sklearn.metrics.pairwise import cosine_similarity # 使用 XLM-RoBERTa 模型和分词器 model_name = "xlm-roberta-base" tokenizer = XLMRobertaTokenizer.from_pretrained(model_name) model = XLMRobertaModel.from_pretrained(model_name) # 准备要比较的文本 text1 = "I love natural language processing." text2 = "I enjoy working with NLP tasks." # 对文本进行编码 inputs1 = tokenizer(text1, return_tensors="pt", padding=True, truncation=True) inputs2 = tokenizer(text2, return_tensors="pt", padding=True, truncation=True) # 获取模型输出 with torch.no_grad(): outputs1 = model(**inputs1) outputs2 = model(**inputs2) # 使用句子级别的 embedding 表示 embedding1 = outputs1.last_hidden_state[:, 0, :].numpy() embedding2 = outputs2.last_hidden_state[:, 0, :].numpy() # 计算余弦相似度 cos_sim = cosine_similarity(embedding1, embedding2) print(f"Cosine Similarity: {cos_sim[0][0]}")

代码解析：

加载模型和分词器：
- XLMRoBertaTokenizer 和 XLMRobertaModel 从 transformers 库中加载。它们内置使用 SentencePiece 进行分词。
文本编码：
- 使用分词器对文本进行分词和编码，返回张量格式的 token ids 和 attention masks。
模型推理：
- 通过模型的前向传播，获得最后一层的隐藏状态张量。我们选用 [CLS] token 的向量作为整个句子的表示。
相似度计算：
- 使用余弦相似度计算两个句子表示之间的相似度，提供了一种量化的语义距离衡量方式。

小技巧和注意事项：

SentencePiece 分词对模型预训练的数据类型适应性好，能很好的处理多语言输入且不需要对输入做过多预处理（比如繁琐的清洗或标点处理）。
模型计算过程中需要关注内存和计算资源，模型越大，计算的性能要求越高。
对于批量处理、长文本，需要考虑分块处理的策略，以及如何将分块结果做整合处理。
该方法的精度和性能将显著依赖于模型选择和数据配置，通常更复杂的模型（如 xlm-roberta-large）提供更佳的语义捕捉能力。

最终建议：对大多数现代去重任务，SentencePiece（Unigram模式） 是更优解，尤其在多语言和专业领域场景。仅在纯英文且对速度敏感时选择经典BPE。

一、SentencePiece vs BBPE 核心优势

特性	SentencePiece	BBPE
算法支持	支持BPE/Unigram两种算法	仅限BPE变种
空格处理	原生支持（无需特殊符号）	需用`_`替代空格
控制字符	内置`<s>`/`</s>`等	需手动添加
多语言混合	自动平衡不同语言覆盖率	需调整字节分布
训练速度	快（支持并行训练）	较慢（字节级统计）
典型用户	T5、mT5、LLaMA-2	GPT-3、GPT-4

BPE/SentencePiece：本质是字符串匹配+哈希表查找，时间复杂度O(n)

示例：处理1万字符的文本仅需：

python

复制

# SentencePiece基准测试（i5-12600K）
import sentencepiece as spm
sp = spm.SentencePieceProcessor(model_file='spm.model')
%timeit sp.encode("Hello world")  # 输出：15.7 µs ± 82.6 ns per loop

(2) 内存访问瓶颈

分词性能主要受内存带宽限制，GPU并行优势无法发挥：

复制
```
CPU L1缓存延迟：~1纳秒
GPU显存延迟：~100纳秒
```

(3) 预分词优化

现代分词器（如HuggingFace Tokenizers）使用Rust加速：

python

复制

from tokenizers import Tokenizer
tokenizer = Tokenizer.from_pretrained("bert-base-uncased")
%timeit tokenizer.encode("Hello world")  # 8.2 µs/loop

3. 需要GPU的例外情况

场景	原因	解决方案
超大词表（>1M）	哈希冲突增多	改用更高效的分词器（如SentencePiece）
流式批处理	单线程CPU吞吐量不足	多进程并行（Python `multiprocessing`）
与大模型联合使用	分词作为模型前馈一部分	整体模型GPU加速

4. 工程优化建议

(1) 极致性能配置

python

复制

# 启用多线程分词（HuggingFace示例）
from tokenizers import Tokenizer, processors
tokenizer = Tokenizer.from_pretrained("bert-base-uncased")
tokenizer.enable_padding(pad_id=0, pad_token="[PAD]")
tokenizer.enable_truncation(max_length=512)
tokenizer.post_processor = processors.TemplateProcessing(
    single="[CLS] $A [SEP]",
    pair="[CLS] $A [SEP] $B [SEP]",
    special_tokens=[("[CLS]", 1), ("[SEP]", 2)]
)

(2) 内存映射优化

对于超大词表（如50万+）：

python

复制

import mmap
with open('vocab.txt', 'r') as f:
    mm = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)
    # 直接操作内存映射文件

(3) 预编译加速

bash

复制

# 编译安装优化版SentencePiece
git clone https://github.com/google/sentencepiece
cd sentencepiece && mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release -DSPM_ENABLE_SHARED=OFF
make -j $(nproc)
sudo make install

5. 性能实测对比

在Intel Xeon 8380（32核）上的测试：

操作	耗时（CPU）	耗时（GPU V100）	加速比
BPE编码10万条文本	1.2秒	3.5秒	0.34x
SentencePiece分词	0.8秒	2.1秒	0.38x
BBPE字节处理	1.5秒	4.2秒	0.36x

结论：GPU反而更慢（因数据传输开销）

6. 何时考虑GPU？

唯一场景：当分词与神经网络前馈紧密耦合时（如Transformer的端到端处理）：

from pyspark.sql import SparkSession from pyspark.sql.functions import udf from pyspark.sql.types import StringType import hashlib import numpy as np def simhash(tokens): hashbits = 64 v = [0] * hashbits # Hash each token and update bit vector for t in tokens: h = int(hashlib.md5(t.encode('utf-8')).hexdigest(), 16) for i in range(hashbits): bitmask = 1 << i if h & bitmask: v[i] += 1 else: v[i] -= 1 # Create simhash based on bit vector simhash = 0 for i in range(hashbits): if v[i] >= 0: simhash |= (1 << i) return bin(simhash) # Spark setup spark = SparkSession.builder \ .appName("SimHashExample") \ .getOrCreate() # Example DataFrame data = [("doc1", ["word1", "word2", "word3"]), ("doc2", ["word2", "word3", "word4"])] columns = ["doc_id", "tokens"] df = spark.createDataFrame(data, columns) # Register UDF simhash_udf = udf(simhash, StringType()) # Apply SimHash df_with_simhash = df.withColumn("simhash", simhash_udf(df.tokens)) df_with_simhash.show(truncate=False)

2. 分段原则

(1) 长度下限（避免过短）

最短≥50字符：
过短的段落容易失去语义完整性，导致误判。
示例：分段"深度学习需要"和"大数据"可能被误认为不相关。

(2) 长度上限（避免过长）

最长≤500字符：
过长的段落会使汉明距离失效（随机差异增大）。
实验数据：当段落>500字符时，相似文本的汉明距离可能>10（64位哈希）。

(3) 重叠滑动窗口

推荐30%-50%重叠：
确保边界内容不被切断，提升连续性检测。

50到500~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

jaccard相似度 ---minhash函数

基础的文档去重是删除重复key，这个key一般是文档的来源，比如网址。之后就是想办法将一篇文档向量化，通过比较两个文档向量的相似度，判断两个文档是否为重复文档。文档向量化的方法有很多，比如使用基于transformer结构的模型比如GLM推出的BGE系列模型，再简单一点的比如fasttext。再比如就是甚至模型都不需要仅仅通过算法就能实现的，也就是本文要介绍的Minhash和Simhash

Hash函数将输入消息分为L LL个固定长度的分组，每一分组长为b bb位，最后一个分组包含输入消息的总长度，若最后一个分组不足b bb位时，需要将其填充为b bb位‘‘

md5和sha-256 sha-1密码算法里b都是512

-------------------------------------------------------

ngram一种分词方法 gram也是后面很多的基础（会考虑局部上下文）：如jieba分词,nltk等

词袋模型不算词向量是后面很多的基础

word2vec基于普通神经网络训练而来，从大型数据集。包括skip-gram和CBOW。

word2vec考虑上下文，但它为每个词生成的嵌入在训练完成后是固定的，而后面的模型预测会动态调整。（但是Word2vec比bert这些小很多，还是有其应用价值的）

glove可以被看作是更换了目标函数和权重函数的全局word2vec

fastText:ngram划分词袋+word2vec等预训练模型得到词向量，然后结合起来

【bert,gpt预训练模型技术，前者基于wordpiece，后者基于BPE】

现代分词技术：BPE =WORD2PIECE <UNIGRAM <SENTENCEPIECE

【在bert\gpt处理的前置环节仍然应用这些分词技术】

在 Hugging Face 的 Transformers 库中，bert-base-multilingual-cased 模型使用的分词器实际上是基于 WordPiece 的，而不是 SentencePiece 或 BPE (Byte Pair Encoding)。

解释：

WordPiece:
- WordPiece 是一种子词分词算法，最初由 Google 提出并应用在 BERT 模型中。它通过迭代地合并最常见的字符对或子词来构建词汇表。
- 在构建 BERT 模型（包括多语言版本）时，WordPiece 被用来创建包含词汇表的分词器。这些分词器是经过大规模训练并能有效应对不同的语言输入。
SentencePiece:
- SentencePiece 是来自 Google 的一个独立的分词库和模型，用于无语言依赖的文本字符串到子词序列转换，经常用于属于不同模型的分词器，例如 T5、XLM-RoBERTa 等。
- 它不需要进行语言中的空格或字边界分割，特适合处理有复杂字符集的语言。
BPE (Byte Pair Encoding):
- BPE 是一种通过反复合并频繁出现的字节对而产生词汇表的算法。GPT-2 的分词器使用的是变种 BPE，称作 Byte Level BPE。

所以，在使用 bert-base-multilingual-cased 加载的分词器时，实际上它使用了 WordPiece 分词机制，而不是 SentencePiece。了解这一点在选择模型时可以帮助更好地理解这些工具在不同语言任务中的适用性和效能。

如果你需要使用 SentencePiece 的具体模型，可以另外寻找 T5 或 XLM-R 等，因为它们的实现中使用了 SentencePiece。

工业使用：simhash

但是

直接对字符做 N-Gram（如 4-gram）可能产生无意义片段（如 “的天气” → "的天"、"天气"），而 BPE 分词的 N-Gram 更接近语义单元。
例如：

BPE 分词后：“深度学习” → "深" + "度" + "学习" → 生成 2-gram："深度"、"度学"、"学习"
原始字符 4-gram："深度学"、"度学习"
预处理阶段，直接使用tokenizer.tokenize即可，除了长度控制，不需要单独去掉停用词。
如果说，觉得数据不干净，可以提前清洗，例如：去掉html格式、去掉\u等无效字符。直接re就好了。

对语义敏感的去重任务（如论文、客服对话），推荐 BPE + SimHash；对大规模表面去重（如爬虫数据），可仅用 字符/词级 N-Gram + SimHash。

字符级N-Gram是“最细粒度但最表面”的方法，适合无分词需求的场景。
词级N-Gram依赖分词工具，适合传统NLP任务。
BPE是深度学习的桥梁，平衡效率与语义，但需额外训练成本。

工业级去重流水线（长文本）：

第一阶段：字符级N-Gram快速粗筛。
第二阶段：BPE+语义模型精筛（比如论文查重）

小规模数据：直接使用Word2Vec词向量平均 + 余弦相似度。
大规模生产环境：
- 第一阶段：SimHash/MinHash快速粗筛。
- 第二阶段：SBERT或Doc2Vec精筛。
优先 SimHash：
- 数据量小 + 表面重复为主（如日志、代码）。
优先 Word2Vec：
- 数据量小 + 需基础语义识别（如商品描述、短文本聚类）。
优先 BERT：
- 数据量小 + 高精度要求（如法律条款、学术论文）

-----------------------------------------------

基于one-hot、tf-idf、textrank等的bag-of-words；
主题模型：LSA（SVD）、pLSA、LDA；
基于词向量的固定表征：word2vec、fastText、glove
基于词向量的动态表征：elmo、GPT、bert
--------------------------------------------------------------------------------------------

Minhash算法:为每个文本生成固定长度的最小值集合的签名

客服对话等很短的文本去重：word2vec+simhash

SimHash

优点：
- 高效：计算复杂度低，适合亿级文本去重（如Google爬虫去重）。
- 可解释性：汉明距离直接反映表面相似性（如重复段落、轻微改写）。
- 对词序不敏感：适合容忍词序变化的场景（如“猫追狗” vs “狗追猫”）。
缺点：
- 语义盲区：无法识别同义替换或深层语义相似性（如“iPhone” vs “苹果手机”）。
- 依赖特征工程：需手动选择N-Gram长度或停用词处理。

BERT

优点：
- 语义感知：识别同义替换、句式变换甚至跨语言相似性（如“你好” vs “Hello”）。
- 上下文敏感：区分多义词（如“银行”在金融 vs 河流上下文）。
缺点：
- 计算成本高：单个文本需数百毫秒（BERT-base），需批处理优化。
- 维度灾难：高维向量（如768维）需降维或近似最近邻（ANN）检索（如Faiss）。

3. 实际效果对比

表面重复（如仅修改标点）：
SimHash和BERT均能有效检测，但SimHash更快。
语义重复（如改写句子）：
BERT胜出。例如：
- 原文：“深度学习模型需要大量数据。”
- 改写：“训练神经网络依赖海量样本。”
  SimHash可能漏检，而BERT能通过语义匹配发现。

4. 混合方案（工业级实践）

粗筛 + 精筛：
- 先用SimHash快速过滤重复率>90%的文本，减少计算量。
- 对剩余文本用BERT或Sentence-BERT（SBERT）计算语义相似度。

------------------------------------------------------------------------------------------------------------------------------

何时选择不加 N-Gram？

场景：
- 语义去重（如客服对话、商品描述）。
- 资源受限（需最小化计算量）。
案例：
- BPE 分词后直接 SimHash，适合社交媒体短文本去重。

何时选择加入 N-Gram？

场景：
- 需检测局部改写（如论文查重）。
- 处理混合语言文本（如中英文混杂时，BPE 可能跨语言分词）。
案例：
- 学术论文去重中，BPE + 3-Gram SimHash 能同时捕捉术语和句式重复。

-------------------------------------------------------------------------------------------------------------------------------

文本向量化：

Transformer架构已经成为自然语言处理（NLP）领域的核心技术之一，其最显著的特点就是基于注意力机制来处理序列数据。Transformer模型可以用于文本向量化，通常包括以下主要的方法和技术：

1. 基于Transformer的向量化方法

Bert (Bidirectional Encoder Representations from Transformers)

描述：Bert利用Transformer的编码器部分，采用双向注意力机制来预训练语言模型。它能够捕获句子中的上下文关系。
预训练：Bert预训练使用两个任务：Masked Language Model (MLM) 和 Next Sentence Prediction (NSP)。
下游应用：可以微调用于多种NLP任务，如文本分类、问答系统等。

GPT (Generative Pre-trained Transformer)

描述：GPT系列是基于Transformer解码器部分的架构，擅长生成文本（如对话和文本生成任务）。
预训练：使用自回归模型进行预训练，预测文本序列中的下一个token。
应用：在需要文本生成或自然语言生成的任务中表现优异。

T5 (Text-to-Text Transfer Transformer)

描述：T5将所有NLP任务统一为文本到文本的格式，通过一体化的方法处理多种任务。
应用：通过任务特定的微调来处理分类、翻译、摘要等任务。

RoBERTa

描述：RoBERTa是Bert的一个改进版本，通过更大的数据和更长的训练来提升效果。同时去除NSP任务以专注于MLM。
优势：通过更优化的训练方法和数据使用来显著提升效果。

DistilBERT

描述：Bert的一个轻量级版本，保持Bert效果的同时减少了参数数量（约40%）。
应用：适用于需要减少计算资源的任务。

2. 文本向量化流程

Tokenization：
- 使用特定模型的分词器（如BERTTokenizer）把文本分割成token，并将token转换为输入ID。
Embedding：
- 将token ID转化为嵌入向量，表示为固定长度的数值序列。
应用预训练模型：
- 利用预训练的Transformer模型（如BERT），将token嵌入输入模型，以输出各层的上下文嵌入。
输出向量获取：
- 常用的方法是提取最后一层输出或中间某层的表示，作为文本的向量化表示。

BertTokenizer 是 BERT 模型在处理文本输入时常用的一个分词器，它的主要功能是将文本转化为模型可以理解和处理的格式。具体来说，BertTokenizer 对文本进行以下几步处理：

分词结果

分词 (Tokenization)：
- 文本被分割成基本的单元，称为 token。这一步可能会拆分单词成子词或字符，尤其是对未登录词（out-of-vocabulary）的处理。BERT 使用一种称为 WordPiece 的分词技术。
- 例如，BertTokenizer 可以将文本 "unaffable" 分割为 ["un", "##aff", "##able"]。这种"##" 表示这是一个词的一部分，被称为子词分词。
插入特殊标记：
- 在输入序列的开始和结束分别插入特殊标记 [CLS] 和 [SEP]。例如，对于输入 "Hello, how are you?"，它可能被分词为 ["[CLS]", "hello", ",", "how", "are", "you", "?", "[SEP]"]。
词汇表索引化 (Token IDs)：
- 将每个 token 转换为其对应的索引（token id），这是根据 BERT 的词汇表进行映射的。这样，每个 token 就能被转换成一个整数序列。这是模型实际处理的数据。同样地，上面的例子可能转换为 [101, 7592, 1010, 2129, 2024, 2017, 1029, 102]。
生成注意力掩码 (Attention Mask)：
- 一个与输入tokens同长度的向量，用于指示 padding的位置，常用于区分实际输入和填充。被填充部分用 0 表示，而有效输入部分用 1 表示。
处理不可见字符与非法字符：
- 自动去除或替换可能导致问题的字符，以确保输入合法化。

使用方法

以下是使用Hugging Face的transformers库对文本进行BERT向量化的简化示例：

from transformers import BertTokenizer

# 加载预训练的BERT

tokenizer tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

# 输入文本

text = "Hello, how are you?"

# 分词

tokens = tokenizer.tokenize(text)

print("Tokens:", tokens)

# 将分词后的 tokens 转换为对应的 token IDs

token_ids = tokenizer.convert_tokens_to_ids(tokens)

print("Token IDs:", token_ids)

# 编码并生成模型可直接使用的输入

inputs = tokenizer(text, return_tensors="pt")

print("Input IDs:", inputs["input_ids"])

print("Attention Mask:", inputs["attention_mask"])

是的，MD5（Message-Digest Algorithm 5）方法确实非常快。这是因为MD5设计的初衷之一就是高效的散列计算，以下几点解释了为何MD5速度很快：

1. 简单设计

固定操作流程：MD5采用了固定的处理步骤，包括位操作、加法和循环移位。这些操作在计算机上非常高效，因为它们可以在一个或仅几个处理器周期内完成。
定长输出：无论输入数据大小，MD5总是产生固定长度（128位）的哈希值。这简化了很多处理和存储操作。

2. 块处理机制

分块处理：MD5将输入数据分为长度固定的512位块，每个块独立处理。这种设计不仅简化了算法的复杂性，也使得其能在处理大型数据时表现得很高效。

3. 广泛优化

硬件和软件优化：由于MD5出现较早并广泛使用，很多处理器和编译器对其进行了优化。此外，大量成熟的软件库和框架提供了高度优化的MD5实现。
缓存友好性：其操作保持良好的数据局部性，能充分利用现代计算机的缓存系统。

4. 无过多复杂性

较少条件分支：相对于一些现代加密算法，MD5避免了复杂的条件分支，这减少了分支预测失败导致的性能损失。

5. 并行性和流水线

促进并行计算：虽然MD5本身是线性过程，但是在硬件实现或在使用特定优化技术时，可以对多个数据块的处理进行并行化。

需要注意的方面：

尽管MD5非常高效，但在安全性方面存在显著缺陷。MD5被认为不安全，因为它容易受到碰撞攻击（即，两个不同的输入可以产生相同的哈希值）。因此，在安全敏感的场合（如密码加密和数字签名）通常建议使用更安全的哈希算法，如SHA-256。

综上所述，MD5的快速性能在于它的简单设计、固定长度输出和优化实施，这些使得它在许多非安全领域仍然是一个有效的选择。然而，在需要安全保证的情况下，应选择更现代和安全的哈希算法。

当使用 PySpark 或其他分布式计算框架执行 groupBy 操作时，理解其背后的执行机制对于评估性能至关重要。以下是关于 PySpark 的 groupBy 操作是如何在集群上执行的，以及为什么在特定情况下它可能比单机运行更高效：

PySpark 的 GroupBy 执行机制

数据分区：
- 在 PySpark 中，数据集（RDD 或 DataFrame）被划分为多个分区。每个分区可以在集群的不同节点上进行并行处理。
分区内处理：
- PySpark 的 groupBy 操作确实需要跨分区进行，因为同一个组值可能会存在于不同的分区中。但在执行过程中，PySpark 会先在每个分区内进行局部的分组处理，尽可能地减少数据的移动。
Shuffle 操作：
- 完成分区内的局部分组后，PySpark 会在集群中执行数据的 Shuffle 操作，将同一组的所有数据集中到一个节点上进行汇总。这是一个网络密集型操作，因为它涉及节点间的数据交换。
汇总和计算：
- 在 Shuffle 完成后，最终的汇总计算在各个节点上并行执行。

PySpark 对比单机性能

并行处理：
- 即使整个 groupBy 需要进行网络数据传输，PySpark 在分布式环境中执行多个分区上处理的并行性，可以大幅缩短处理时间。
计算资源利用：
- 在一个分布式集群中，多个节点的 CPU、内存和 I/O 资源可以同时被利用，使得任务可以处理比单机内存更大的数据集。
数据规模：
- 对于非常大的数据集，单机（比如 Pandas）可能超出内存限制，导致崩溃或需要虚拟内存支持。PySpark 的分布式处理可以处理超出单个机器内存的数据集。
弹性和容错性：
- PySpark 可以在节点失效的情况下自动恢复任务，确保计算的鲁棒性和连续性。这在大型和关键任务中非常重要。

使用场景对比

小规模数据集：如果你的数据集可以完全放入一台机器的内存，且处理时间在可承受范围内，Pandas 或其他单机工具可能更高效，因为省去了网络传输的开销。
大规模数据集：如果数据集大到需要使用分布式计算来处理（特别是当完整数据无法放入单机内存），PySpark 可能显著提高处理效率。

总结

尽管 groupBy 不是独立在每个分区上执行的，PySpark 依然通过其分布式特性为需要大规模数据处理的任务提供了高效的解决方案。在选择方案时，必须根据数据规模、可用资源和特定需求进行权衡和判断。

解析一下下面的pyspark去重代码是怎么在每个分区对整体哈希索引进行计算的
def get_minhash(line):
    text = line['text']
    tokens = gram_3(minhash_tokenizer.tokenize(text))
    m = MinHash(num_perm=200)
    m.update_batch([token.encode() for token in tokens])
    line['minhash'] = m.digest().tolist()
    return line
def get_LSH_keys(hash:list,bands):
    num_perm = len(hash)
    rows = num_perm // bands
    bulks = []
    for i in range(bands):
        start = i * rows
        end = (i+1) * rows
        features = hash[start:end]
        bulks.append(f'bulk:{i}_'+md5(','.join([str(f) for f in features])))
    return bulks

def scatter_hash_bulk(line):
    minhash = line['minhash']
    LSH_keys = get_LSH_keys(minhash,LSH.b)
    doc_info = {}
    doc_info['hashindex'] = line['hashindex']
    doc_info['minhash'] = line['minhash']
    doc_info['qs'] = line.get('qs',-1)
    output = [[lsh,doc_info] for lsh in LSH_keys]
    return output
def deduplicate(group):
    def jaccard_similarity(signature1, signature2):
        assert len(signature1) == len(signature2), "Signatures must be of the same length"
        count = sum([1 for i in range(len(signature1)) if signature1[i] == signature2[i]])
        return count / len(signature1)

    key,content = group
    docs = sorted([{**doc,'sim_doc':None} for doc in content],key=lambda x:x['hashindex'])
    docs.sort(key=lambda x:x['qs'],reverse=True)
    retained_docs = []
    for i,doc in enumerate(docs):
        if i == 0:
            retained_docs.append(doc)
        else:
            for j,retained_doc in enumerate(retained_docs):
                sim_score = jaccard_similarity(retained_doc['minhash'],doc['minhash'])
                if sim_score >= hash_threshold:
                    doc['sim_doc'] = retained_doc['hashindex']
                    break

            if doc['sim_doc'] is not None:
                retained_docs.append(doc)
            else:
                output = {'hashindex':doc['hashindex'],'sim_doc':doc['sim_doc']}
                yield output
def merge_deduplicate(group):
    key,content = group
    merged_res = None
    for res in content:
        if merged_res is None:
            merged_res = res
            continue
        if res['sim_doc'] is not None:
            merged_res['sim_doc'] = res['sim_doc']
            break
    return merged_res

from transformers import AutoTokenizer
from datasketch import MinHash,MinHashLSH

minhash_tokenizer = AutoTokenizer.from_pretrained('Your tokenizer')
LSH = MinHashLSH(lsh_threshold, 200)
gram_3 = Ngram(3)
path = qs_temp_path
qs_rdd = spark.sparkContext.textFile(path).map(load_json).zipWithIndex().map(lambda x:{**x[0],'hashindex':x[1]})
minhash_rdd = qs_rdd.map(get_minhash).cache()
minhash_rdd.map(remove_minhash).map(dump_json).repartition(1000).saveAsTextFile(minhash_temp_path)

minhash_bulks_rdd = minhash_rdd.flatMap(scatter_hash_bulk)
deduplicate_res_rdd = minhash_bulks_rdd.groupByKey().flatMap(deduplicate)
deduplicate_res_rdd.groupBy(lambda x:x['hashindex']).map(merge_deduplicate).map(remove_minhash).map(dump_json).saveAsTextFile(dd_temp_path

Word2Vec 可以被视为一种模型，同时它也可以像查表一样使用，这取决于你是如何看待其机制和应用的。

Word2Vec 作为模型

训练:
- Word2Vec 是通过训练获得的，它使用大规模的文本语料库来学习词汇表中每一个单词的向量表示（embedding）。训练过程主要基于两个架构之一：Skip-gram 或 CBOW（Continuous Bag of Words）。
模型机制:
- CBOW: 通过上下文词预测中心词。
- Skip-gram: 通过一个词预测其周围的上下文词。
学习结果:
- 通过训练，Word2Vec 学习到的权重就构成了词嵌入空间，即每一个单词都有一个相应的向量。
- 这些向量是高维空间中的点，词与词之间的余弦相似度代表它们的语义相似性。
优点:
- 相比统计词频的词袋模型，Word2Vec 捕捉到的语义信息更加丰富和细致。
- 可以推理出词语间的关系，例如“king - man + woman ≈ queen”。

Word2Vec 作为查表

查表功能:
- 一旦模型训练完成，词嵌入实际上就是一个查找表。每一个单词对应一个高维向量，这个查表允许快速获取单词的向量表示。
- 在实际应用中，如相似性匹配、聚类、或简单的词向量获取，Word2Vec 已经完成训练阶段，嵌入表就是一个定值表，系统可以从中直接查找和利用向量。
使用场景:
- 快速检索词向量表示，进行相似度计算、加法运算等。
- 在需要通过词向量利用深度学习或其他算法的场合，查表能够显著提高效率。

总结

训练阶段: Word2Vec 是一个通过大量数据训练所得的模型，它的任务是学习词嵌入。
应用阶段: 在应用上，Word2Vec 的结果通常被使用为一个查找表，即任何时候都可以高效率地获得单词的向量表示。

因此，Word2Vec 的性质既可以解释为一种模型（在训练角度），也可以看做一个查表结构（在应用角度）。这种两重属性使得它在开发上线后非常高效和易用。

BERT 的出现是自然语言处理（NLP）领域的一项重要创新，其在许多任务上都取得了优异的表现。不过，Word2Vec 在某些场景中依然具有其独特的应用价值和优势。

BERT 的优势

上下文感知: BERT 是上下文感知的，这意味着它可以为同一个词在不同上下文中生成不同的表示。这在考虑词义分歧时特别有用。
双向编码: BERT 使用双向 Transformer，从左到右和从右到左同时处理文本，因此捕捉到了更丰富的句子级别的语义信息。
迁移学习: 预训练的 BERT 模型可以用于多种下游任务，只需要在特定任务上进行微调。
高性能: 在许多基准测试中，BERT 都显示出卓越的性能，尤其在问答、情感分析、文本分类等任务中。

Word2Vec 的优势

效率和资源使用: Word2Vec 相对简单和轻量，这在资源受限的环境中非常有用。计算和内存消耗都比 BERT 要小得多。
快速训练和部署: Word2Vec 在训练速度和模型大小上有优势，这使得它特别适合于快速开发或需要处理大规模数据的情境。
简单性: 对于需要简单词向量表示的任务，Word2Vec 的实现和使用更为直接且易于理解。
可解释性: Word2Vec 的训练机制基于语言建模，通过简单的加权平均或线性组合即能得到语义友好的词向量。

Word2Vec 仍然有用的场景

资源受限环境: 在设备有限、资源紧缺的情况下，Word2Vec 是一个合适的选择。
简单任务: 对于不需要复杂上下文分析的任务，Word2Vec 依旧能够提供良好的性能。
词语相似性和聚类: 在只需考虑词语的静态相似性或聚类任务中，Word2Vec 可能已经足够。
特定领域应用: 在非常专门的领域下，训练专门的 Word2Vec 模型可能表现优于通用的 NLP 模型。
数据量敏感的任务: 对于小数据集任务，训练复杂模型如 BERT 可能面临不足拟合问题，而 Word2Vec 更容易合适。

总结

虽然 BERT 在很多场合都显示出其强大的功能和性能，但 Word2Vec 由于其简便性、效率和在简单任务中的有效性，仍然具备应用价值。在选择使用哪种模型时，应根据具体任务的资源环境、性能需求和对上下文依赖的程度来做出评估。BERT 与 Word2Vec 并不一定是相互排斥的选择，而是在合适的场合下各自发挥优势。

在当前大型语言模型（Large Language Models, LLMs）大行其道的背景下，BERT 这样的预训练模型依然具有其相应的价值和用途。以下是几个方面的分析：

1. 资源消耗与效率

计算资源: 大型语言模型（如 GPT-3、ChatGPT 等）通常需要更高的计算能力和存储资源。而 BERT 相对小巧，可以在较小规模的数据和较少的计算资源下有效使用。
效率: 对于一些特定任务，尤其是需要快速处理和低延时的应用场景，小型模型如 BERT 可以在保持性能的同时提高效率。

2. 特殊任务和领域的适应

任务专注: BERT 是通过 Masked Language Model 和 Next Sentence Prediction 等任务进行预训练的，非常适合基于句子级和段落级的理解任务，比如问答、文本分类和命名实体识别等。
定制化: 预训练后的 BERT 模型可以通过微调（fine-tuning）适应特定任务或领域，而大模型通常是通用大规模生成和理解模型，尽管在适应性上亦很强，但也可能在过度定制化方面需要更多资源和时间。