福田建网站多少钱,滨州的网站开发,郑州建设网站哪家好,山西省住房建设厅网站迁移学习
1、fasttext概述
作为NLP工程领域常用的工具包, fasttext有两大作用#xff1a;进行文本分类、训练词向量
正如它的名字, 在保持较高精度的情况下, 快速的进行训练和预测是fasttext的最大优势。fasttext工具包中内含的fasttext模型具有十分简单的网络结构。使用fa…迁移学习
1、fasttext概述
作为NLP工程领域常用的工具包, fasttext有两大作用进行文本分类、训练词向量
正如它的名字, 在保持较高精度的情况下, 快速的进行训练和预测是fasttext的最大优势。fasttext工具包中内含的fasttext模型具有十分简单的网络结构。使用fasttext模型训练词向量时使用层次softmax结构, 来提升超多类别下的模型性能。由于fasttext模型过于简单无法捕捉词序特征, 因此会进行n-gram特征提取以弥补模型缺陷提升精度。
2、fasttext模型架构
FastText 模型架构和 Word2Vec 中的 CBOW 模型很类似, 不同之处在于, FastText 预测标签, 而 CBOW 模型预测中间词。
FastText的模型分为三层架构:
输入层: 是对文档embedding之后的向量, 包含N-gram特征隐藏层: 是对输入数据的求和平均输出层: 是文档对应的label
(一)、层次softmax
为了提高效率, 在fastText中计算分类标签概率的时候, 不再使用传统的softmax来进行多分类的计算, 而是使用哈夫曼树, 使用层次化的softmax来进行概率的计算。
(1)、哈夫曼树
当利用n 个结点试图构建一棵树时, 如果构建的这棵树的带权路径长度最小, 称这棵树为“最优二叉树”, 有时也叫“赫夫曼树”或者“哈夫曼树”。
权值越大的节点距离根节点也较近。
(2)、构建哈夫曼树
假设有n个权值, 则构造出的哈夫曼树有n个叶子节点. n个权值分别设为 w1、w2、…、wn, 则哈夫曼树的构造规则为:
步骤1: 将w1、w2、…, wn看成是有n 棵树的森林(每棵树仅有一个节点);步骤2: 在森林中选出两个根节点的权值最小的树合并, 作为一颗新树的左、右子树, 且新树的根节点权值为其左、右子树根节点权值之和;步骤3: 从森林中删除选取的两棵树, 并将新树加入森林;步骤4: 重复2-3步骤, 直到森林只有一颗树为止, 该树就是所求的哈夫曼树。
(3)、哈夫曼树编码
哈夫曼编码一般规定哈夫曼树中的左分支为 0, 右分支为 1, 从根节点到每个叶节点所经过的分支对应的 0 和 1 组成的序列便为该节点对应字符的编码。这样的编码称为哈夫曼编码。
(二)、负采样
(1)、策略
减少计算softmax的token数量。
噪声词获取策略指定拿到噪声词的数量K每个噪声词token被取为噪声词的概率为 P f ( t i ) 0.75 ∑ ( f ( t j ) 0.75 ) P\frac{f(t_i)^{0.75}}{\sum(f(t_j)^{0.75})} P∑(f(tj)0.75)f(ti)0.75
(2)、优势
提高训练速度, 选择了部分数据进行计算损失, 损失计算更加简单改进效果, 增加部分负样本, 能够模拟真实场景下的噪声情况, 能够让模型的稳健性更强泛化能力更强
3、fasttext文本分类
模型训练
# 进行文本分类任务(有监督)input输入的文本
lr学习率
epoch训练轮次
wordNgramn-gram特征
dim词向量维度
loss计算损失的方式默认是softmaxhs还可以选择ova代表one vs all改变意味着我们在统一语料下同时训练多个二分类模型fasttext.train_supervised()
# 进行文本分类任务(无监督)
fasttext.train_unsupervised()预测
model.predict(需要预测的内容)# 返回结果
# 元组中的第一项代表标签, 第二项代表对应的概率测试
model.test(验证集/测试集)# 返回结果
# 元组中的每项分别代表, 验证集样本数量, 精度以及召回率保存模型
model.save_model(模型存储位置)重加载模型
fasttext.load_model(模型存储位置)4、训练词向量
(一)、训练词向量的过程
获取数据训练词向量模型超参数设定模型效果检验模型的保存与重加载
(二)、API
获得指定词汇的词向量
model.get_word_vector(word指定词汇)查找邻近词
model.get_nearest_neighbors(word指定词汇)5、词向量迁移
大型语料库上已经进行训练完成的词向量模型我们可以直接使用这些模型或者对模型进行改造。
下载词向量模型压缩的bin.gz文件解压bin.gz文件到bin文件加载bin文件获取词向量利用邻近词进行效果检验
# 使用gunzip进行解压, 获取cc.zh.300.bin文件
gunzip cc.zh.300.bin.gz
# 加载模型
model fasttext.load_model(cc.zh.300.bin)
# 使用模型获得音乐这个名词的词向量
model.get_word_vector(海鸥)
# 以音乐为例, 返回的邻近词基本上与音乐都有关系, 如乐曲, 音乐会, 声乐等
model.get_nearest_neighbors(海鸥)6、迁移学习
(一)、概述
(1)、预训练模型
一般情况下预训练模型都是大型模型具备复杂的网络结构众多的参数量以及在足够大的数据集下进行训练而产生的模型.。
在NLP领域预训练模型往往是语言模型。因为语言模型的训练是无监督的可以获得大规模语料同时语言模型又是许多典型NLP任务的基础如机器翻译文本生成阅读理解等
常见的预训练模型有BERT, GPT, roBERTa, transformer-XL等
(2)、微调
根据给定的预训练模型改变它的部分参数或者为其新增部分输出结构后通过在小部分数据集上训练来使整个模型更好的适应特定任务
(3)、两种迁移方式 直接使用预训练模型进行相同任务的处理不需要调整参数或模型结构这些模型开箱即用。但是这种情况一般只适用于普适任务, 如fasttest工具包中预训练的词向量模型。另外很多预训练模型开发者为了达到开箱即用的效果将模型结构分各个部分保存为不同的预训练模型提供对应的加载方法来完成特定目标。 更主流的迁移学习方式是发挥预训练模型特征抽象的能力然后再通过微调的方式通过训练更新小部分参数以此来适应不同的任务。这种迁移方式需要提供小部分的标注数据来进行监督学习。
(二)、NLP中常见的预训练模型
(1)、常见的训练模型
BERT、GPT、GPT-2、Transformer-XL、XLNet、XLM、RoBERTa、DistilBERT、ALBERT、T5、XLM-RoBERTa
(2)、BERT及其变体
bert-base-uncased: 编码器具有12个隐层, 输出768维张量, 12个自注意力头, 共110M参数量, 在小写的英文文本上进行训练而得到.bert-large-uncased: 编码器具有24个隐层, 输出1024维张量, 16个自注意力头, 共340M参数量, 在小写的英文文本上进行训练而得到.bert-base-cased: 编码器具有12个隐层, 输出768维张量, 12个自注意力头, 共110M参数量, 在不区分大小写的英文文本上进行训练而得到.bert-large-cased: 编码器具有24个隐层, 输出1024维张量, 16个自注意力头, 共340M参数量, 在不区分大小写的英文文本上进行训练而得到.bert-base-multilingual-uncased: 编码器具有12个隐层, 输出768维张量, 12个自注意力头, 共110M参数量, 在小写的102种语言文本上进行训练而得到.bert-large-multilingual-uncased: 编码器具有24个隐层, 输出1024维张量, 16个自注意力头, 共340M参数量, 在小写的102种语言文本上进行训练而得到.bert-base-chinese: 编码器具有12个隐层, 输出768维张量, 12个自注意力头, 共110M参数量, 在简体和繁体中文文本上进行训练而得到.
(3)、GPT
openai-gpt: 编码器具有12个隐层, 输出768维张量, 12个自注意力头, 共110M参数量, 由OpenAI在英文语料上进行训练而得到
(4)、GPT-2及其变体
gpt2: 编码器具有12个隐层, 输出768维张量, 12个自注意力头, 共117M参数量, 在OpenAI GPT-2英文语料上进行训练而得到.gpt2-xl: 编码器具有48个隐层, 输出1600维张量, 25个自注意力头, 共1558M参数量, 在大型的OpenAI GPT-2英文语料上进行训练而得到.
(5)、Transformer-XL
transfo-xl-wt103: 编码器具有18个隐层, 输出1024维张量, 16个自注意力头, 共257M参数量, 在wikitext-103英文语料进行训练而得到
(6)、XLNet及其变体
xlnet-base-cased: 编码器具有12个隐层, 输出768维张量, 12个自注意力头, 共110M参数量, 在英文语料上进行训练而得到.xlnet-large-cased: 编码器具有24个隐层, 输出1024维张量, 16个自注意力头, 共240参数量, 在英文语料上进行训练而得到.
(6)、XLM
xlm-mlm-en-2048: 编码器具有12个隐层, 输出2048维张量, 16个自注意力头, 在英文文本上进行训练而得到
(7)、RoBERTa及其变体
roberta-base: 编码器具有12个隐层, 输出768维张量, 12个自注意力头, 共125M参数量, 在英文文本上进行训练而得到.roberta-large: 编码器具有24个隐层, 输出1024维张量, 16个自注意力头, 共355M参数量, 在英文文本上进行训练而得到.
(8)、DistilBERT及其变体
distilbert-base-uncased: 基于bert-base-uncased的蒸馏(压缩)模型, 编码器具有6个隐层, 输出768维张量, 12个自注意力头, 共66M参数量.distilbert-base-multilingual-cased: 基于bert-base-multilingual-uncased的蒸馏(压缩)模型, 编码器具有6个隐层, 输出768维张量, 12个自注意力头, 共66M参数量.
(9)、ALBERT
albert-base-v1: 编码器具有12个隐层, 输出768维张量, 12个自注意力头, 共125M参数量, 在英文文本上进行训练而得到.albert-base-v2: 编码器具有12个隐层, 输出768维张量, 12个自注意力头, 共125M参数量, 在英文文本上进行训练而得到, 相比v1使用了更多的数据量, 花费更长的训练时间.
(10)、T5及其变体
t5-small: 编码器具有6个隐层, 输出512维张量, 8个自注意力头, 共60M参数量, 在C4语料上进行训练而得到.t5-base: 编码器具有12个隐层, 输出768维张量, 12个自注意力头, 共220M参数量, 在C4语料上进行训练而得到.t5-large: 编码器具有24个隐层, 输出1024维张量, 16个自注意力头, 共770M参数量, 在C4语料上进行训练而得到.
(11)、XLM-RoBERTa及其变体
xlm-roberta-base: 编码器具有12个隐层, 输出768维张量, 8个自注意力头, 共125M参数量, 在2.5TB的100种语言文本上进行训练而得到.xlm-roberta-large: 编码器具有24个隐层, 输出1027维张量, 16个自注意力头, 共355M参数量, 在2.5TB的100种语言文本上进行训练而得到.
(三)、Transformers库使用
(1)、Transformer库三层应用结构
管道Pipline方式高度集成的极简使用方式只需要几行代码即可实现一个NLP任务。自动模型AutoMode方式可载入并使用BERTology系列模型。具体模型SpecificModel方式在使用时需要明确指定具体的模型并按照每个BERTology系列模型中的特定参数进行调用该方式相对复杂但具有较高的灵活度。
(2)、编码解码函数
一、编码
tokenizer.encode()
tokenizer.tokenize()
tokenizer.encode_plus()
tokenizer.batch_encode_plus()
tokenizer.convert_tokens_to_ids()1、tokenizer.encode()
# 1、tokenizer.encode()
# 进行分词和token转换encodetokenizeconvert_tokens_to_ids
# 单个句子 or 句子列表分开编码分开padding一个句子对应一个向量
# 句子对pair和句子元组tuple组合编码统一padding句子之间用 102 隔开# 单个句子默认只返回 input_ids
out tokenizer.encode(textsents[0],truncationTrue,paddingmax_length,max_length20,return_tensorspt
)
print(out)
print(out.shape)
# exit()# pair对中的两个句子合并编码默认只返回 input_ids
out tokenizer.encode(text(sents[0], sents[1]),truncationTrue,paddingmax_length,max_length20,return_tensorspt,
)
print(out)
print(out.shape)2、tokenizer.tokenize()
# 2、tokenizer.tokenize()
# 只做分词
out tokenizer.tokenize(textsents[:2],truncationTrue,paddingmax_length,max_length20,return_tensorspt
)
print(out)3、tokenizer.encode_plus()
# 3、tokenizer.encode_plus()
# 在encode的基础之上生成input_ids、token_type_ids、attention_mask
# 单个句子编码默认返回 input_ids、token_type_ids、attention_mask
out tokenizer.encode_plus(textsents[0],truncationTrue,paddingmax_length,max_length20,return_tensorspt
)
print(out)
# exit()# pair对合并编码
# todo 注意 token_type_ids
out tokenizer.encode_plus(text(sents[0], sents[1]),truncationTrue,paddingmax_length,max_length20,return_tensorspt
)
print(out)4、tokenizer.batch_encode_plus()
# 4、tokenizer.batch_encode_plus()
# 在encode_plus的基础之上能够批量梳理文本
# 批量编码
out tokenizer.batch_encode_plus(batch_text_or_text_pairssents,truncationTrue,paddingmax_length,max_length20,return_tensorspt
)
print(out[input_ids].shape)
# exit()# 批量编码 成对句子
out tokenizer.batch_encode_plus(# pair内编码为一句话统一padding列表内分别编码分别paddingbatch_text_or_text_pairs[(sents[0], sents[1]), (sents[2], sents[3])],truncationTrue,paddingmax_length,max_length20,return_tensorspt
)
print(out[input_ids].shape)5、tokenizer.convert_tokens_to_ids()
# 5、tokenizer.convert_tokens_to_ids()
# convert_tokens_to_ids将token转化成id在分词之后。
# convert_ids_to_tokens,将id转化成token通常用于模型预测出结果查看时使用。
out [tokenizer.convert_tokens_to_ids(i) for i in sents[0]]
print(out)二、解码
tokenizer.decode()
tokenizer.convert_ids_to_tokens()1、tokenizer.decode()
res1 tokenizer.decode(out[input_ids][0])
print(res1)2、tokenizer.convert_ids_to_tokens()
res2 [tokenizer.convert_ids_to_tokens(i.item()) for i in out[input_ids][0]]
print(res2)(3)、管道方式完成多种NLP任务
一、文本分类任务
文本分类是指模型可以根据文本中的内容来进行分类。句子级别的分类。
# 导入工具包
import torch
from transformers import pipeline
import numpy as np# 实现情感分析
def text_classcify():# 1 定义模型model pipeline(tasksentiment-analysis, model./model/chinese_sentiment)# 2 直接预测res model(我爱北京天安门天安门上太阳升。)print(res)二、特征提取任务
特征抽取任务只返回文本处理后的特征属于预训练模型的范畴。特征抽取任务的输出结果需要和其他模型一起工作。
# 实现特征提取拿到词向量用于下游任务
def feature_extraction():# 1 创建piplinemodel pipeline(taskfeature-extraction, model./model/bert-base-chinese)# 2 模型预测res model(去码头整点薯条)print(res)print(type(res))print(np.array(res).shape)
# 输出结果
# output--- class list (1, 9, 768)
# 7个字变成9个字原因: [CLS] 去 码 头 整 点 薯 条 [SEP]不带任务头输出特征抽取任务属于不带任务头输出本bert-base-chinese模型的9个字每个字的特征维度是768带头任务头输出其他有指定任务类型的比如文本分类完型填空属于带头任务输出会根据具体任务类型不同输出不同的结果
三、完形填空任务
完型填空任务又被叫做“遮蔽语言建模任务”它属于BERT模型训练过程中的子任务。分类任务。
# 完形填空任务
def fill_mask():model pipeline(taskfill-mask, model./model/chinese-bert-wwm)res model(我想明天去[MASK]家吃饭。)print(res)# 输出结果
# output---
# [{score: 0.34331339597702026, token: 1961, token_str: 她, sequence: 我 想 明 天 去 她 家 吃 饭.},
# {score: 0.2533259987831116, token: 872, token_str: 你, sequence: 我 想 明 天 去 你 家 吃 饭.},
# {score: 0.1874391734600067, token: 800, token_str: 他, sequence: 我 想 明 天 去 他 家 吃 饭.},
# {score: 0.1273055076599121, token: 2769, token_str: 我, sequence: 我 想 明 天 去 我 家 吃 饭.},
# {score: 0.02162978984415531, token: 2644, token_str: 您, sequence: 我 想 明 天 去 您 家 吃 饭.}]四、阅读理解任务
阅读理解任务又称为“抽取式问答任务”即输入一段文本和一个问题让模型输出结果。
# 阅读理解
def qa():context 我叫张三我是一个程序员我的喜好是打篮球。questions [我是谁, 我是做什么的, 我的爱好是什么]model pipeline(taskquestion-answering, model./model/chinese_pretrain_mrc_roberta_wwm_ext_large)res model(contextcontext, questionquestions)print(res)# 输出结果[{score: 1.2071758523357623e-12, start: 2, end: 4, answer: 张三},{score: 2.60890374192968e-06, start: 9, end: 12, answer: 程序员},{score: 4.1686924134864967e-08, start: 18, end: 21, answer: 打篮球}]五、文本摘要任务
摘要生成任务的输入一一段文本输出是一段概况、简单的文字。
# 5 文本摘要
def summary():model pipeline(tasksummarization, model./model/distilbart-cnn-12-6)text BERT is a transformers model pretrained on a large corpus of English data \in a self-supervised fashion. This means it was pretrained on the raw texts \only, with no humans labelling them in any way (which is why it can use lots \of publicly available data) with an automatic process to generate inputs and \labels from those texts. More precisely, it was pretrained with two objectives:Masked \language modeling (MLM): taking a sentence, the model randomly masks 15% of the \words in the input then run the entire masked sentence through the model and has \to predict the masked words. This is different from traditional recurrent neural \networks (RNNs) that usually see the words one after the other, or from autoregressive \models like GPT which internally mask the future tokens. It allows the model to learn \a bidirectional representation of the sentence.Next sentence prediction (NSP): the models \ concatenates two masked sentences as inputs during pretraining. Sometimes they correspond to \sentences that were next to each other in the original text, sometimes not. The model then \has to predict if the two sentences were following each other or not.res model(text)print(res)# 输出结果
output--- [{summary_text: BERT is a transformers model pretrained on a large corpus of English data in a self-supervised fashion . It was pretrained with two objectives: Masked language modeling (MLM) and next sentence prediction (NSP) This allows the model to learn a bidirectional representation of the sentence .}]六、NER任务
**实体词识别NER**任务是NLP中的基础任务。它用于识别文本中的人名PER、地名LOC、组织ORG以及其他实体MISC等。例如(王 B-PER) (小 I-PER) (明 I-PER) (在 O) (北 B-LOC) (京 I-LOC)。其中O表示一个非实体B表示一个实体的开始I表示一个实体块的内部。
实体词识别本质上是一个分类任务又叫序列标注任务token级别的分类任务实体词识别是句法分析的基础而句法分析优势NLP任务的核心。
ner命名实体识别、实体抽取两阶段 分别是 边界识别 and 实体分类常见的命名实体人名、地名、机构名、时间、日期、货币、百分比句子里边的关键信息一般由命名实体承载场景意图识别、关键词抽取、知识图谱信息抽取实体抽取、关系抽取、事件抽取属性抽取
def ner():model pipeline(taskner, model./model/roberta-base-finetuned-cluener2020-chinese)res model(特朗普第二次担任了美国总统)print(res)(4)、自动模型方式完成多种NLP任务
AutoTokenizer、AutoModelForSequenceClassification函数可以自动从官网下载预训练模型也可以加载本地的预训练模型AutoModelForSequenceClassification类管理着分类任务会根据参数的输入选用不同的模型。AutoTokenizer的encode()函数使用return_tensors’pt‘参数和不使用pt参数对文本编码的结果不同AutoTokenizer的encode()函数使用paddingmax_length’可以按照最大程度进行补齐俗称打padding调用模型的forward函数输入return_dictFalse参数返回结果也不同
一、文本分类任务
# 导入工具包
import torch
from transformers import AutoConfig, AutoModel, AutoTokenizer
from transformers import AutoModelForSequenceClassification, AutoModelForMaskedLM, AutoModelForQuestionAnswering
# AutoModelForSeq2SeqLM文本摘要
# AutoModelForTokenClassificationner
from transformers import AutoModelForSeq2SeqLM, AutoModelForTokenClassification# 实现文本分类
def text_classify():# chinese_sentiment 是一个5分类# 1 加载切词器分词word2idBPEmy_tokenizer AutoTokenizer.from_pretrained(./model/chinese_sentiment)# 2 加载模型 # SequenceClassification 句子级别的分类# TokenClassification token级别的分类my_model AutoModelForSequenceClassification.from_pretrained(./model/chinese_sentiment)# 3 准备数据样本句子# message 人生该如何起头# message 我的人生很灰暗# message 我的人生很辉煌message 我不同意你的看法# message 我对你的看法表示中立# message 我很同意你的看法# message 你的看法太棒了我非常同意# message [艾海两只黄鹂鸣翠柳, 一行白鹭上青天]# 4 对句子进行编码 encodeoutput1 my_tokenizer.encode(message,return_tensorspt, # 可选 pttorch tensor tftensorflow NonelisttruncationTrue, # 超过 max-len 就进行截断paddingmax_length, # True 根据最长的句子进行补齐’max_length‘ 根据设置的max_length进行补齐max_length20 # 设置句子的最大长度)print(output1)print(output1.shape)# exit()# 不设置 pt返回 listoutput2 my_tokenizer.encode(message,# return_tensorspt,truncationTrue,paddingTrue,max_length20)print(output2)# 5 使用模型进行预测my_model.eval() # 开启模型预测验证result my_model(output1)print(result)result2 my_model(output1, return_dictFalse)print(result2)# 结果分析topv, topi torch.topk(result.logits, k1, dim-1)print(star, topi.item())二、特征提取任务
# 特征提取 拿到词向量 句向量
# todo token_type_ids attention_mask
def feature_extraction():# 1 加载分词器my_tokenizer AutoTokenizer.from_pretrained(./model/bert-base-chinese)print(my_tokenizer)# 2 加载模型my_model AutoModel.from_pretrained(./model/bert-base-chinese)# 3 准备样本message [你是谁, 人生该如何起头]# 4 样本编码output my_tokenizer.batch_encode_plus(message, # message 句子列表有多句话所以用的 batch_encode_plusreturn_tensorspt,truncationTrue,paddingmax_length, # 不够就补0max_length20,)# output 一般有3个kv对input_ids 就是token具体的编码结果 前后加 [CLS] [SEP]# input_ids: tensor([# [101, 872, 3221, 6443, 102, 0, 0, 0, 0, 0, 0, 0,# 0, 0, 0, 0, 0, 0, 0, 0# ],# [101, 782, 4495, 6421, 1963, 862, 6629, 1928, 102, 0, 0, 0,# 0, 0, 0, 0, 0, 0, 0, 0# ]# attention_mask 标识 padding 的位置 为 0正常的有意义的 token 标识为 1# attention_mask: tensor([# [1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],# [1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]# ])# token_type_ids 在一条样本内部第一个句子标识为 0第二个句子表示为 1# token_type_ids: tensor([# [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], # 因为此处只有一个句子所以只有0# [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]# ]),print(output)# 5 将数据送入到模型my_model.eval()res my_model(**output)print(res)print(res.last_hidden_state.shape) # 词向量 ner token级别的分类print(res.pooler_output.shape) # 句向量 文本分类三、完形填空任务
# 完形填空
def fill_mask():# 1 加载分词器my_tokenizer AutoTokenizer.from_pretrained(./model/chinese-bert-wwm)print(my_tokenizer)# 2 加载模型my_model AutoModelForMaskedLM.from_pretrained(./model/chinese-bert-wwm)# 3 准备样本message 我想明天去[MASK]家吃饭# 4 对样本进行编码output my_tokenizer.encode_plus(message, return_tensorspt)print(output)# 5 将数据送入模型my_model.eval()res my_model(**output).logits # res.shape(1,11,vocab_size)print(res.shape)# res[0][6][mask]对应的输出向量长度vocab_size# torch.argmax(res[0][6]) 拿到最大值所在下表索引index torch.argmax(res[0][6]).item()print(index)# 6 拿到 mask 对应的 tokentoken my_tokenizer.convert_ids_to_tokens(index)print(token)四、阅读理解任务
def qa():# 1 加载分词器my_tokenizer AutoTokenizer.from_pretrained(./model/chinese_pretrain_mrc_roberta_wwm_ext_large)# 2 加载模型my_model AutoModelForQuestionAnswering.from_pretrained(./model/chinese_pretrain_mrc_roberta_wwm_ext_large)# 3 准备语料context 我叫张三 我是一个程序员 我的喜好是打篮球questions [我是谁, 我是做什么的, 我的爱好是什么]# 4 将数据送入模型my_model.eval()for question in questions:print(question)# pair对 进行统一合并编码inputs my_tokenizer.encode_plus(question, context, return_tensorspt)outputs my_model(**inputs)print(outputs)# 拿到输出的开始的logit结束的logit通过argmax拿到indexstart_index torch.argmax(outputs.start_logits, dim-1).item()end_index torch.argmax(outputs.end_logits, dim-1).item()# 来到inputs中做切片, a 是id序列a inputs[input_ids][0][start_index: end_index 1]# 对 a 进行解码res my_tokenizer.convert_ids_to_tokens(a)print(res)五、文本摘要任务
def summary():# 1 加载分词器my_tokenizer AutoTokenizer.from_pretrained(./model/distilbart-cnn-12-6)# 2 加载模型my_model AutoModelForSeq2SeqLM.from_pretrained(./model/distilbart-cnn-12-6)# 3 准备语料# text BERT is a transformers model pretrained on a large corpus of English data \# in a self-supervised fashion. This means it was pretrained on the raw texts \# only, with no humans labelling them in any way (which is why it can use lots \# of publicly available data) with an automatic process to generate inputs and \# labels from those texts. More precisely, it was pretrained with two objectives:Masked \# language modeling (MLM): taking a sentence, the model randomly masks 15% of the \# words in the input then run the entire masked sentence through the model and has \# to predict the masked words. This is different from traditional recurrent neural \# networks (RNNs) that usually see the words one after the other, or from autoregressive \# models like GPT which internally mask the future tokens. It allows the model to learn \# a bidirectional representation of the sentence.Next sentence prediction (NSP): the models \# concatenates two masked sentences as inputs during pretraining. Sometimes they correspond to \# sentences that were next to each other in the original text, sometimes not. The model then \# has to predict if the two sentences were following each other or not.text I have a dream.# 4 把文本进行张量表示inputs my_tokenizer.encode_plus(text, return_tensorspt)# 5 将数据送入模型进行解码my_model.eval()outputs my_model.generate(inputs[input_ids])print(outputs)# skip_special_tokensTrue 跳过特殊符号 BERT的特殊符号 CLS SEP PAD UNK MASK# clean_up_tokenization_spacesFalse 是否清理空字符res my_tokenizer.decode(outputs[0], skip_special_tokensTrue, clean_up_tokenization_spacesTrue)print(res)六、NER任务
命名实体识别、实体抽取
def ner():# 1 加载分词器、模型、配置configmy_tokenizer AutoTokenizer.from_pretrained(./model/roberta-base-finetuned-cluener2020-chinese)my_model AutoModelForTokenClassification.from_pretrained(./model/roberta-base-finetuned-cluener2020-chinese)my_config AutoConfig.from_pretrained(./model/roberta-base-finetuned-cluener2020-chinese)# 2 准备数据并进行张量化text 我爱北京天安门天安门上太阳升inputs my_tokenizer.encode_plus(text, return_tensorspt)print(inputs: , inputs)# 3 将tensor送入到模型拿到 id-token因为 inputs 已经添加了特殊符号my_model.eval()# logits 是模型返回的主要张量用来做token分类的outputs my_model(**inputs).logits# 因为原来的 inputs 已经添加了特殊符号而特殊符号也需要标签labeltokens my_tokenizer.convert_ids_to_tokens(inputs[input_ids][0])print(tokens:, tokens)# 4 预测结果# 初始化返回结果的列表output_listoutput_list []# 循环遍历 具体的token及其对应的标签tensor这个tensor未经过argmax的# logit 是一个一维的tensorfor token, logit in zip(tokens, outputs[0]):# 跳过特殊符号if token in my_tokenizer.all_special_tokens:continueindex torch.argmax(logit, dim-1).item()# 根据id拿到具体的标签labellabel my_config.id2label[index]# 封装 token及其标签 进 output_listoutput_list.append((token, label))print(output_list)(四)、微调方式进行迁移学习
(1)、迁移学习的两种类型 直接加载预训练模型进行输入文本的特征表示, 后接自定义网络进行微调输出结果 使用指定任务类型的微调脚本微调预训练模型, 后接带有输出头的预定义网络输出结果
(2)、中文分类
一、导包
import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
from datasets import load_dataset # 用来加载数据
from transformers import BertModel, BertTokenizer
from transformers import AdamW
import time
import shutup二、加载分词器和模型
shutup.please() # 去掉无意义的警告# 定义设备
device torch.device(cuda if torch.cuda.is_available() else cpu)# 加载分词器
my_tokenizer BertTokenizer.from_pretrained(./model/bert-base-chinese)# 加载模型, my_model对应的下游任务模型
bert_model BertModel.from_pretrained(./model/bert-base-chinese)三、加载数据
# 3 使用 load_dataset 加载数据
def file2dataset():load_dataset 3种情况情况1 data_files如果传入的是一个字典不同的类型对应的不同的数据文件这个类型就是split情况2 如果直接传入数据文件路径直接写死 splittrain 没有意义了情况3 不使用data_files使用data_dir那么直接返回一个 dataset dict根据 key 去检索数据文件 dataset[train]my_files {train: ./data/train.csv,test: ./data/test.csv,valid: ./data/validation.csv,}# 加载训练集, load_dataset 三个参数数据文件格式、文件路径、类型train_dataset load_dataset(csv, data_filesmy_files, splittrain)print(train_dataset[0])# 测试集test_dataset load_dataset(csv, data_filesmy_files, splittest)# 验证集valid_dataset load_dataset(csv, data_filesmy_files, splitvalid)return train_dataset, test_dataset, valid_dataset四、对同一批次的数据做标准化
# 4 自定义批处理函数, 对一个批次的数据做标准化
def collate_fn(data):# data[{text:xxx, label:1}, {},{},,,]# 主要作用对句子长度进行规范化规范到统一的标准长度sents [i[text] for i in data]labels [i[label] for i in data]# print(sents)# print(labels)inputs my_tokenizer.batch_encode_plus(sents,# 是否截断truncationTrue,# paddingpaddingmax_length,max_length500,# 返回tensor默认列表return_tensorspt,# 返回长度return_lengthTrue)input_ids inputs[input_ids]token_type_ids inputs[token_type_ids]attention_mask inputs[attention_mask]labels torch.LongTensor(labels)return input_ids, token_type_ids, attention_mask, labels五、获得dataloader
# 5 测试数据集获得dataloader
def get_dataloader():train_dataset load_dataset(csv, data_files./data/train.csv, splittrain)my_dataloader DataLoader(train_dataset,batch_size8, # 一个 batch 有 8 条样本shuffleTrue, # 将数据打乱collate_fncollate_fn, # 批处理函数统一句子长度drop_lastTrue, # 删除最后一个不足一个 batch 的数据)# 通过 next(iter()) 方法拿到一个batch的数据input_ids, token_type_ids, attention_mask, labels next(iter(my_dataloader))# print(input_ids)# print(token_type_ids)# print(labels)return my_dataloader六、自定义下游任务模型
# 6 自定义下游任务模型
class MyModel(nn.Module):def __init__(self):super().__init__()# 适配下游任务一个线性层self.linear nn.Linear(768, 2)def forward(self, input_ids, token_type_ids, attention_mask): # 参数均为编码的结果# 不对预训练模型的参数更新with torch.no_grad():# 输出两个值词向量和句向量bert_output bert_model(input_idsinput_ids,attention_maskattention_mask,token_type_idstoken_type_ids)output self.linear(bert_output.pooler_output) # 可以不做 softmax后续有嵌套return output七、模型训练
# 7 模型训练
def train_model():# 1 准备物料: 模型、损失函数、优化器、数据my_model MyModel().to(device)# 把bert参数固定住for param in bert_model.parameters():param.requires_grad_(False)# CrossEntropyLoss 本身自带 softmaxmy_loss_fn nn.CrossEntropyLoss(reductionmean)my_adamw AdamW(my_model.parameters(), lr3e-4)# 拿到数据my_dataloader get_dataloader()# 2 开始训练my_model.train()epochs 3for epoch_idx in range(epochs):# 记录开始时间start_time time.time()for i, (input_ids, token_type_ids, attention_mask, labels) in enumerate(my_dataloader, start1):input_ids input_ids.to(device)token_type_ids token_type_ids.to(device)attention_mask attention_mask.to(device)labels labels.to(device)# 训练的4步前向传播、计算损失、损失反向传播、参数更新、梯度清零output my_model(input_ids, token_type_ids, attention_mask)loss my_loss_fn(output, labels)loss.backward()my_adamw.step()my_adamw.zero_grad()# 每隔几步 打印日志if i % 2 0:# 根据 argmax 拿到预测值 idxtem torch.argmax(output, dim-1)# 计算准确率预测正确的 / 总的数量acc (tem labels).sum().item() / len(labels)use_time time.time() - start_timeprint(当前训练轮次%d,迭代步数%d,损失%.2f,准确率%.2f,时间%d % (epoch_idx 1,i,loss.item(),acc,use_time))# 每隔epoch保存一次模型torch.save(my_model.state_dict(), ./save/classify_%d.bin % (epoch_idx 1))八、模型评估
# 9 模型评估
def ceshi_model():# 1 准备物料 必要 模型 数据 也可以有损失test_dataset load_dataset(csv, data_files./data/test.csv, splittrain)test_dataloader DataLoader(test_dataset,batch_size8,shuffleTrue,collate_fncollate_fn,drop_lastTrue,)my_model MyModel()my_model.load_state_dict(torch.load(./save/classify_3.bin))# 2 开始测试correct 0 # 预测正确的样本数量total 0 # 总的样本数量# 开启模型验证模式my_model.eval()# 只需要一个epoch即可for i, (input_ids, token_type_ids, attention_mask, labels) in enumerate(test_dataloader, start1):# 数据放到 with torch.no_grad() 执行with torch.no_grad():output my_model(input_ids, token_type_ids, attention_mask)temp torch.argmax(output, dim-1)# 把当前batch的预测正确的、总的数量分别加到correct、totalcorrect (temp labels).sum().item()total len(labels)# 打印日志if i % 2 0:print(平均acc, correct / total)text my_tokenizer.decode(input_ids[0], skip_special_tokensTrue)print(当前batch第一个原始文本, text)print(模型的预测结果, temp[0])print(真是结果是, labels[0])print(模型总的acc, correct / total)
