Hugging Face中transformers库

目录

使用预训练好的bert来对你的文本做嵌入向量

我们需要用一个向量来代表整句话的意思。通常有两种做法：

取 [CLS] 向量：

2.平均池化（Mean Pooling）： 将句子中除了填充符（padding）之外所有 token 的向量在 768 这个维度上求平均值。这在很多检索任务中效果比直接取 [CLS] 更好。

更严谨的 Mean Pooling 操作

知乎文章的介绍(具体例子看链接)

分词:

BERT对中文是字符级别的分词，对待英文是到sub-word级别的​编辑

MLM任务:

情感分类任务:

使用预训练好的bert来对你的文本做嵌入向量

与传统的固定词向量（如 Word2Vec，一个词永远对应一个向量）不同，BERT 提取的是动态的、基于上下文的 Embedding。也就是说，同一个词在不同句子中，BERT 会为它生成不同的向量。

https://zhuanlan.zhihu.com/p/535100411

https://blog.csdn.net/qq_38463737/article/details/120743532?fromshare=blogdetail&sharetype=blogdetail&sharerId=120743532&sharerefer=PC&sharesource=qq_52122048&sharefrom=from_linkhttps://blog.csdn.net/qq_38463737/article/details/120743532?fromshare=blogdetail&sharetype=blogdetail&sharerId=120743532&sharerefer=PC&sharesource=qq_52122048&sharefrom=from_link

要使用预训练好的 BERT 来对文本做嵌入向量，在 Python 中最标准、最简单的做法是使用 Hugging Face 的transformers库和PyTorch。

import torch from transformers import BertTokenizer, BertModel # 1. 加载预训练的 Tokenizer (分词器) 和 Model (模型) # "bert-base-chinese" 是 Hugging Face 上专门针对中文的预训练模型 model_name = "bert-base-chinese" tokenizer = BertTokenizer.from_pretrained(model_name) model = BertModel.from_pretrained(model_name) # 2. 准备你的文本 text = "老师能否再解释一下什么是embedding？" # 3. 对文本进行 Tokenize 处理 # 这步会把文本切分成词汇，并转换为模型需要的输入格式 (包含 input_ids, attention_mask 等) # return_tensors="pt" 表示返回 PyTorch 的张量 (Tensor) inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True) # 4. 将处理好的数据输入给 BERT 模型 # 使用 torch.no_grad() 是因为我们只是用模型做推理提取向量，不需要更新权重，这样可以节省内存并加速 with torch.no_grad(): outputs = model(**inputs) # 5. 获取 Embedding 向量！ # outputs.last_hidden_state 包含了文本中每一个 token 的向量表示 token_embeddings = outputs.last_hidden_state print("Token Embeddings 的形状:", token_embeddings.shape)

当你运行上面的代码后，token_embeddings的形状通常是类似这样的：[1, 18, 768]。这三个数字分别代表：

• 1 (Batch Size):表示我们输入了 1 个句子。

• 18 (Sequence Length):表示这个句子被切分成了 18 个 token（包括 BERT 自动添加的特殊符号[CLS]和[SEP]）。

• 768 (Hidden Size):这是 BERT-base 模型的默认维度。也就是说，每一个 token 都被转换成了一个长度为 768 的实数向量。

场景 A：我想要“单个词”的向量

如果你想知道句子中“解释”这个词的向量，你只需要在token_embeddings中找到对应位置的向量即可。这就等同于我们上一个问题中提到的，赋予了上下文含义的词向量 u。

场景 B：我想要“整个句子”的向量（最常见）

在文本分类、语义相似度匹配（比如计算两个句子意思近不近）中，

我们需要用一个向量来代表整句话的意思。通常有两种做法：

1. 取[CLS]向量：

   BERT 强制在每个输入的开头添加一个特殊占位符叫[CLS]。经过注意力机制的层层计算，这个位置的输出向量通常被认为聚合了整个句子的全局语义信息。

# 提取第0个位置的向量，即 [CLS] token 的向量 sentence_embedding_cls = token_embeddings[0, 0, :] print("句子向量(CLS)形状:", sentence_embedding_cls.shape) # 输出: torch.Size([768])

2.平均池化（Mean Pooling）：将句子中除了填充符（padding）之外所有 token 的向量在 768 这个维度上求平均值。这在很多检索任务中效果比直接取[CLS]更好。

# 将所有 token 的向量求平均 sentence_embedding_mean = torch.mean(token_embeddings[0], dim=0) print("句子向量(Mean)形状:", sentence_embedding_mean.shape) # 输出: torch.Size([768])

1.token_embeddings[0]：取出第一句话

BERT 输出的token_embeddings默认包含了“批次（Batch）”的概念，形状是[句子数量, 字数, 特征维度]（例如[1, 18, 768]）。

• 加了[0]，意思就是：“我只要这批数据里的第 1 句话”。

• 取出来之后，数据就变成了一个二维表格，形状是[18, 768]。你可以把它想象成一个 Excel 表：有 18 行（代表 18 个字），768 列（代表每个字的 768 个特征）。

2.dim=0：指定求平均的方向

在[18, 768]这个表格里：

• dim=0指的是竖直方向（跨越不同的行）。

• dim=1指的是水平方向（跨越不同的列）。

3.torch.mean(...)：执行平均操作

当我们设定dim=0时，torch.mean就会沿着竖直方向，把这 18 个字在第 1 列的特征求平均，第 2 列的特征求平均……一直算到第 768 列。

最终结果：原本 18 行的字向量，被上下“压扁”成了一行。你得到了一个形状为[768]的一维向量，这个向量就是这句话的句向量（Sentence Embedding）。

更严谨的 Mean Pooling 操作

虽然上面的代码能帮助你直观理解dim=0的作用，但在实际工程中，句子通常长短不一。为了组成 Batch，我们会用特殊的[PAD]（填充符）把短句子补齐。

直接使用torch.mean会把这些毫无意义的[PAD]向量也算进平均值里，从而“污染”句子的语义。

因此，更严谨的 Mean Pooling 会利用前一步tokenizer输出的attention_mask，把 padding 的位置遮蔽掉，只对真正有意义的词求平均：

# 假设 token_embeddings 形状为 [1, 18, 768] # inputs['attention_mask'] 形状为 [1, 18]，真实词为 1，PAD 为 0 # 1. 扩展 mask 的维度，使其能够与 embeddings 相乘：[1, 18] -> [1, 18, 1] input_mask_expanded = inputs['attention_mask'].unsqueeze(-1).expand(token_embeddings.size()).float() # 2. 将 padding 位置的向量清零，然后求和 sum_embeddings = torch.sum(token_embeddings * input_mask_expanded, dim=1) """ pytorch.sum(..., dim=1) 发生了什么： 既然我们要计算“一句话内部所有字的平均值”，我们就应该把这 18 个字融合在一起。 所以我们要指定 dim=1（沿着字的维度）。 PyTorch 会顺着 dim=1 的方向，把这 18 个字的特征加起来（变成 1 个大一统的字）。 原本 [1, 18, 768] 的形状，中间那个 18 被“压扁”了，计算后的结果形状变成了 [1, 768]。 """ # 3. 计算每个句子实际的非 padding token 数量 (防止除以 0) sum_mask = torch.clamp(input_mask_expanded.sum(dim=1), min=1e-9) # 4. 求真正的平均值 (此时按 batch 维度处理，针对第1个维度 seq_len 求和/平均) sentence_embedding_mean = sum_embeddings / sum_mask

1.expand()是什么意思？为什么要把 mask 扩展？

目的：为了让“开关”和“数据”的形状完全一样，才能相乘。

• 初始状态：inputs['attention_mask']的形状是[1, 18]。里面装的是1（代表真实的字）和0（代表为了补齐句子而填充的无意义占位符 PAD）。你可以把它当成 18 个“开关”。

• 遇到的问题：我们的token_embeddings形状是[1, 18, 768]。也就是说，这 18 个字，每一个字背后都有 768 个特征数字。你不能直接把一个一维的开关[18]去乘以一个三维的矩阵[1, 18, 768]。

• unsqueeze(-1)的作用：先给 mask 增加一个空维度，把它变成[1, 18, 1]。现在的意思是：我们有 18 个字，每个字分配了 1 个开关。

• expand(token_embeddings.size())的作用：token_embeddings.size()就是[1, 18, 768]。expand会把那个空维度1复制、拉伸成768。

例子:

我的手写模拟图:

知乎文章的介绍(具体例子看链接)

(29 封私信) Huggingface 超详细介绍 - 知乎https://zhuanlan.zhihu.com/p/535100411

分词:

# 上文的示例代码已经实例话了，这里不重复了； print(tokenizer.encode("生活的真谛是美和爱")) # 对于单个句子编码 print(tokenizer.encode_plus("生活的真谛是美和爱","说的太好了")) # 对于一组句子编码 # 输出结果如下： [101, 4495, 3833, 4638, 4696, 6465, 3221, 5401, 1469, 4263, 102] {'input_ids': [101, 4495, 3833, 4638, 4696, 6465, 3221, 5401, 1469, 4263, 102, 6432, 4638, 1922, 1962, 749, 102], 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1], 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]} # 也可以直接这样用 sentences = ['网络安全开发分为三个层级', '车辆系统层级网络安全开发', '车辆功能层级网络安全开发', '车辆零部件层级网络安全开发', '测试团队根据车辆网络安全目标制定测试技术要求及测试计划', '测试团队在网络安全团队的支持下，完成确认测试并编制测试报告', '在车辆确认结果的基础上，基于合理的理由，确认在设计和开发阶段识别出的所有风险均已被接受',] test1 = tokenizer(sentences) print(test1) # 对列表encoder print(tokenizer("网络安全开发分为三个层级")) # 对单个句子encoder

BERT对中文是字符级别的分词，对待英文是到sub-word级别的

MLM任务:

情感分类任务:

import torch from torch.utils.data import DataLoader,Dataset import os import re from random import sample import numpy as np import torch.nn as nn import torch.nn.functional as F import torch.optim as optim from transformers import BertModel, BertTokenizer from tqdm import tqdm # 路径需要根据情况修改，要看你把数据下载到哪里了 # 数据下载地址在斯坦福官网，网上搜索就有 data_base_path = r"./imdb_test/aclImdb" # 这个里面是存储你训练出来的模型的，现在是空的 model_path = r"./imdb_test/aclImdb/mode" #1. 准备dataset，这里写了一个数据读取的类，并把数据按照不同的需要进行了分类； class ImdbDataset(Dataset): def __init__(self,mode,testNumber=10000,validNumber=5000): # 在这里我做了设置，把数据集分成三种形式，可以选择 “train”默认返回全量50000个数据，“test”默认随机返回10000个数据， # 如果是选择“valid”模式，随机返回相应数据 super(ImdbDataset,self).__init__() # 读取所有的训练文件夹名称 text_path = [os.path.join(data_base_path,i) for i in ["test/neg","test/pos"]] text_path.extend([os.path.join(data_base_path,i) for i in ["train/neg","train/pos"]]) if mode=="train": self.total_file_path_list = [] # 获取训练的全量数据，因为50000个好像也不算大，就没设置返回量，后续做sentence的时候再做处理 for i in text_path: self.total_file_path_list.extend([os.path.join(i,j) for j in os.listdir(i)]) if mode=="test": self.total_file_path_list = [] # 获取测试数据集，默认10000个数据 for i in text_path: self.total_file_path_list.extend([os.path.join(i,j) for j in os.listdir(i)]) self.total_file_path_list=sample(self.total_file_path_list,testNumber) if mode=="valid": self.total_file_path_list = [] # 获取验证数据集，默认5000个数据集 for i in text_path: self.total_file_path_list.extend([os.path.join(i,j) for j in os.listdir(i)]) self.total_file_path_list=sample(self.total_file_path_list,validNumber) def tokenize(self,text): # 具体要过滤掉哪些字符要看你的文本质量如何 # 这里定义了一个过滤器，主要是去掉一些没用的无意义字符，标点符号，html字符啥的 fileters = ['!','"','#','$','%','&','\(','\)','\*','\+',',','-','\.','/',':',';','<','=','>','\?','@' ,'\[','\\','\]','^','_','`','\{','\|','\}','~','\t','\n','\x97','\x96','”','“',] # sub方法是替换 text = re.sub("<.*?>"," ",text,flags=re.S) # 去掉<...>中间的内容，主要是文本内容中存在<br/>等内容 text = re.sub("|".join(fileters)," ",text,flags=re.S) # 替换掉特殊字符，'|'是把所有要匹配的特殊字符连在一起 return text # 返回文本 def __getitem__(self, idx): cur_path = self.total_file_path_list[idx] # 返回path最后的文件名。如果path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素。 # cur_filename返回的是如：“0_3.txt”的文件名 cur_filename = os.path.basename(cur_path) # 标题的形式是：3_4.txt 前面的3是索引，后面的4是分类 # 如果是小于等于5分的，是负面评论，labei给值维1，否则就是1 labels = [] sentences = [] if int(cur_filename.split("_")[-1].split(".")[0]) <= 5 : label = 0 else: label = 1 # temp.append([label]) labels.append(label) text = self.tokenize(open(cur_path,encoding='UTF-8').read().strip()) #处理文本中的奇怪符号 sentences.append(text) # 可见我们这里返回了一个list，这个list的第一个值是标签0或者1，第二个值是这句话； return sentences,labels def __len__(self): return len(self.total_file_path_list) # 2. 这里开始利用huggingface搭建网络模型 # 这个类继承再nn.module,后续再详细介绍这个模块 # class BertClassificationModel(nn.Module): def __init__(self,hidden_size=768): super(BertClassificationModel, self).__init__() # 这里用了一个简化版本的bert model_name = 'distilbert-base-uncased' # 读取分词器 self.tokenizer = BertTokenizer.from_pretrained(pretrained_model_name_or_path=model_name) # 读取预训练模型 self.bert = BertModel.from_pretrained(pretrained_model_name_or_path=model_name) for p in self.bert.parameters(): # 冻结bert参数 p.requires_grad = False self.fc = nn.Linear(hidden_size,2) def forward(self, batch_sentences): # [batch_size,1] sentences_tokenizer = self.tokenizer(batch_sentences, truncation=True, padding=True, max_length=512, add_special_tokens=True) input_ids=torch.tensor(sentences_tokenizer['input_ids']) # 变量 attention_mask=torch.tensor(sentences_tokenizer['attention_mask']) # 变量 bert_out=self.bert(input_ids=input_ids,attention_mask=attention_mask) # 模型 last_hidden_state =bert_out[0] # [batch_size, sequence_length, hidden_size] # 变量 bert_cls_hidden_state=last_hidden_state[:,0,:] # 变量 fc_out=self.fc(bert_cls_hidden_state) # 模型 return fc_out # 3. 程序入口，模型也搞完啦，我们可以开始训练，并验证模型的可用性 def main(): testNumber = 10000 # 多少个数据参与训练模型 validNumber = 100 # 多少个数据参与验证 batchsize = 250 # 定义每次放多少个数据参加训练 trainDatas = ImdbDataset(mode="test",testNumber=testNumber) # 加载训练集,全量加载，考虑到我的破机器，先加载个100试试吧 validDatas = ImdbDataset(mode="valid",validNumber=validNumber) # 加载训练集 train_loader = torch.utils.data.DataLoader(trainDatas, batch_size=batchsize, shuffle=False)#遍历train_dataloader 每次返回batch_size条数据 val_loader = torch.utils.data.DataLoader(validDatas, batch_size=batchsize, shuffle=False) # 这里搭建训练循环，输出训练结果 epoch_num = 1 # 设置循环多少次训练，可根据模型计算情况做调整，如果模型陷入了局部最优，那么循环多少次也没啥用 print('training...(约1 hour(CPU))') # 初始化模型 model=BertClassificationModel() optimizer = optim.AdamW(model.parameters(), lr=5e-5) # 首先定义优化器，这里用的AdamW，lr是学习率，因为bert用的就是这个 # 这里是定义损失函数，交叉熵损失函数比较常用解决分类问题 # 依据你解决什么问题，选择什么样的损失函数 criterion = nn.CrossEntropyLoss() print("模型数据已经加载完成,现在开始模型训练。") for epoch in range(epoch_num): for i, (data,labels) in enumerate(train_loader, 0): output = model(data[0]) optimizer.zero_grad() # 梯度清0 loss = criterion(output, labels[0]) # 计算误差 loss.backward() # 反向传播 optimizer.step() # 更新参数 # 打印一下每一次数据扔进去学习的进展 print('batch:%d loss:%.5f' % (i, loss.item())) # 打印一下每个epoch的深度学习的进展i print('epoch:%d loss:%.5f' % (epoch, loss.item())) #下面开始测试模型是不是好用哈 print('testing...(约2000秒(CPU))') # 这里载入验证模型，他把数据放进去拿输出和输入比较，然后除以总数计算准确率 # 鉴于这个模型非常简单，就只用了准确率这一个参数，没有考虑混淆矩阵这些 num = 0 model.eval() # 不启用 BatchNormalization 和 Dropout，保证BN和dropout不发生变化,主要是在测试场景下使用； for j, (data,labels) in enumerate(val_loader, 0): output = model(data[0]) # print(output) out = output.argmax(dim=1) # print(out) # print(labels[0]) num += (out == labels[0]).sum().item() # total += len(labels) print('Accuracy:', num / validNumber) if __name__ == '__main__': main()