遷移學習

1、fasttext概述

作為NLP工程領域常用的工具包, fasttext有兩大作用：進行文本分類、訓練詞向量

正如它的名字, 在保持較高精度的情況下, 快速的進行訓練和預測是fasttext的最大優(yōu)勢。fasttext工具包中內含的fasttext模型具有十分簡單的網絡結構。使用fasttext模型訓練詞向量時使用層次softmax結構, 來提升超多類別下的模型性能。由于fasttext模型過于簡單無法捕捉詞序特征, 因此會進行n-gram特征提取以彌補模型缺陷提升精度。

2、fasttext模型架構

FastText 模型架構和 Word2Vec 中的 CBOW 模型很類似, 不同之處在于, FastText 預測標簽, 而 CBOW 模型預測中間詞。

FastText的模型分為三層架構:

• 輸入層: 是對文檔embedding之后的向量, 包含N-gram特征
• 隱藏層: 是對輸入數據的求和平均
• 輸出層: 是文檔對應的label

(一)、層次softmax

為了提高效率, 在fastText中計算分類標簽概率的時候, 不再使用傳統(tǒng)的softmax來進行多分類的計算, 而是使用哈夫曼樹, 使用層次化的softmax來進行概率的計算。

(1)、哈夫曼樹

當利用n 個結點試圖構建一棵樹時, 如果構建的這棵樹的帶權路徑長度最小, 稱這棵樹為“最優(yōu)二叉樹”, 有時也叫“赫夫曼樹”或者“哈夫曼樹”。

權值越大的節(jié)點距離根節(jié)點也較近。

(2)、構建哈夫曼樹

假設有n個權值, 則構造出的哈夫曼樹有n個葉子節(jié)點. n個權值分別設為 w1、w2、…、wn, 則哈夫曼樹的構造規(guī)則為:

• 步驟1: 將w1、w2、…, wn看成是有n 棵樹的森林(每棵樹僅有一個節(jié)點);
• 步驟2: 在森林中選出兩個根節(jié)點的權值最小的樹合并, 作為一顆新樹的左、右子樹, 且新樹的根節(jié)點權值為其左、右子樹根節(jié)點權值之和;
• 步驟3: 從森林中刪除選取的兩棵樹, 并將新樹加入森林;
• 步驟4: 重復2-3步驟, 直到森林只有一顆樹為止, 該樹就是所求的哈夫曼樹。

(3)、哈夫曼樹編碼

哈夫曼編碼一般規(guī)定哈夫曼樹中的左分支為 0, 右分支為 1, 從根節(jié)點到每個葉節(jié)點所經過的分支對應的 0 和 1 組成的序列便為該節(jié)點對應字符的編碼。這樣的編碼稱為哈夫曼編碼。

(二)、負采樣

(1)、策略

減少計算softmax的token數量。

噪聲詞獲取策略：指定拿到噪聲詞的數量K，每個噪聲詞token被取為噪聲詞的概率為
$$P=\frac{f(t_i{)}^{0.75}}{\sum (f(t_j{)}^{0.75})}$$

(2)、優(yōu)勢

• 提高訓練速度, 選擇了部分數據進行計算損失, 損失計算更加簡單
• 改進效果, 增加部分負樣本, 能夠模擬真實場景下的噪聲情況, 能夠讓模型的穩(wěn)健性更強，泛化能力更強

3、fasttext文本分類

• 模型訓練

# 進行文本分類任務(有監(jiān)督)
'''
input：輸入的文本
lr：學習率
epoch：訓練輪次
wordNgram：n-gram特征
dim：詞向量維度
loss：計算損失的方式，默認是softmax，'hs'；還可以選擇'ova'，代表one vs all，改變意味著我們在統(tǒng)一語料下同時訓練多個二分類模型
'''
fasttext.train_supervised()
# 進行文本分類任務(無監(jiān)督)
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領域，預訓練模型往往是語言模型。因為語言模型的訓練是無監(jiān)督的，可以獲得大規(guī)模語料，同時語言模型又是許多典型NLP任務的基礎，如機器翻譯，文本生成，閱讀理解等，

常見的預訓練模型有BERT, GPT, roBERTa, transformer-XL等

(2)、微調

根據給定的預訓練模型，改變它的部分參數或者為其新增部分輸出結構后，通過在小部分數據集上訓練，來使整個模型更好的適應特定任務

(3)、兩種遷移方式

• 直接使用預訓練模型，進行相同任務的處理，不需要調整參數或模型結構，這些模型開箱即用。但是這種情況一般只適用于普適任務, 如：fasttest工具包中預訓練的詞向量模型。另外，很多預訓練模型開發(fā)者為了達到開箱即用的效果，將模型結構分各個部分保存為不同的預訓練模型，提供對應的加載方法來完成特定目標。

• 更主流的遷移學習方式是發(fā)揮預訓練模型特征抽象的能力，然后再通過微調的方式，通過訓練更新小部分參數以此來適應不同的任務。這種遷移方式需要提供小部分的標注數據來進行監(jiān)督學習。

(二)、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參數量, 在不區(qū)分大小寫的英文文本上進行訓練而得到.
• bert-large-cased: 編碼器具有24個隱層, 輸出1024維張量, 16個自注意力頭, 共340M參數量, 在不區(qū)分大小寫的英文文本上進行訓練而得到.
• 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）方式：高度集成的極簡使用方式，只需要幾行代碼即可實現(xiàn)一個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轉換，encode=tokenize+convert_tokens_to_ids
# 單個句子 or 句子列表：分開編碼，分開padding，一個句子對應一個向量
# 句子對（pair）和句子元組（tuple）：組合編碼，統(tǒng)一padding，句子之間用 102 隔開# 單個句子，默認只返回 input_ids
out = tokenizer.encode(text=sents[0],truncation=True,padding='max_length',max_length=20,return_tensors='pt'
)
print(out)
print(out.shape)
# exit()# pair對中的兩個句子，合并編碼，默認只返回 input_ids
out = tokenizer.encode(text=(sents[0], sents[1]),truncation=True,padding='max_length',max_length=20,return_tensors='pt',
)
print(out)
print(out.shape)

<2>、tokenizer.tokenize()

# 2、tokenizer.tokenize()
# 只做分詞
out = tokenizer.tokenize(text=sents[:2],truncation=True,padding='max_length',max_length=20,return_tensors='pt'
)
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(text=sents[0],truncation=True,padding='max_length',max_length=20,return_tensors='pt'
)
print(out)
# exit()# pair對，合并編碼
# todo 注意 token_type_ids
out = tokenizer.encode_plus(text=(sents[0], sents[1]),truncation=True,padding='max_length',max_length=20,return_tensors='pt'
)
print(out)

<4>、tokenizer.batch_encode_plus()

# 4、tokenizer.batch_encode_plus()
# 在encode_plus的基礎之上，能夠批量梳理文本
# 批量編碼
out = tokenizer.batch_encode_plus(batch_text_or_text_pairs=sents,truncation=True,padding='max_length',max_length=20,return_tensors='pt'
)
print(out['input_ids'].shape)
# exit()# 批量編碼 成對句子
out = tokenizer.batch_encode_plus(# pair內編碼為一句話，統(tǒng)一padding，列表內分別編碼，分別paddingbatch_text_or_text_pairs=[(sents[0], sents[1]), (sents[2], sents[3])],truncation=True,padding='max_length',max_length=20,return_tensors='pt'
)
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# 實現(xiàn)情感分析
def text_classcify():# 1 定義模型model = pipeline(task='sentiment-analysis', model='./model/chinese_sentiment')# 2 直接預測res = model('我愛北京天安門，天安門上太陽升。')print(res)

<二>、特征提取任務

特征抽取任務只返回文本處理后的特征，屬于預訓練模型的范疇。特征抽取任務的輸出結果需要和其他模型一起工作。

# 實現(xiàn)特征提取，拿到詞向量，用于下游任務
def feature_extraction():# 1 創(chuàng)建piplinemodel = pipeline(task='feature-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(task='fill-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(task='question-answering', model='./model/chinese_pretrain_mrc_roberta_wwm_ext_large')res = model(context=context, question=questions)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(task='summarization', 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級別的分類任務），實體詞識別是句法分析的基礎，而句法分析優(yōu)勢NLP任務的核心。

• ner（命名實體識別、實體抽取）：兩階段 分別是 邊界識別 and 實體分類
• 常見的命名實體：人名、地名、機構名、時間、日期、貨幣、百分比
• 句子里邊的關鍵信息，一般由命名實體承載，場景：意圖識別、關鍵詞抽取、知識圖譜
• 信息抽取：實體抽取、關系抽取、事件抽取（屬性抽取）

def ner():model = pipeline(task='ner', model='./model/roberta-base-finetuned-cluener2020-chinese')res = model('特朗普第二次擔任了美國總統(tǒng)')print(res)

(4)、自動模型方式完成多種NLP任務

• AutoTokenizer、AutoModelForSequenceClassification函數可以自動從官網下載預訓練模型，也可以加載本地的預訓練模型
• AutoModelForSequenceClassification類管理著分類任務，會根據參數的輸入選用不同的模型。
• AutoTokenizer的encode()函數使用return_tensors=’pt‘參數和不使用pt參數對文本編碼的結果不同
• AutoTokenizer的encode()函數使用padding='max_length’可以按照最大程度進行補齊，俗稱打padding
• 調用模型的forward函數輸入return_dict=False參數，返回結果也不同

<一>、文本分類任務

# 導入工具包
import torch
from transformers import AutoConfig, AutoModel, AutoTokenizer
from transformers import AutoModelForSequenceClassification, AutoModelForMaskedLM, AutoModelForQuestionAnswering
# AutoModelForSeq2SeqLM：文本摘要
# AutoModelForTokenClassification：ner
from transformers import AutoModelForSeq2SeqLM, AutoModelForTokenClassification# 實現(xiàn)文本分類
def text_classify():# chinese_sentiment 是一個5分類# 1 加載切詞器：分詞+word2id（BPE）my_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_tensors='pt',  # 可選 pt（torch tensor） tf（tensorflow） None（list）truncation=True,  # 超過 max-len 就進行截斷padding='max_length',  # True 根據最長的句子進行補齊；’max_length‘ 根據設置的max_length進行補齊max_length=20  # 設置句子的最大長度)print(output1)print(output1.shape)# exit()# 不設置 pt，返回 listoutput2 = my_tokenizer.encode(message,# return_tensors='pt',truncation=True,padding=True,max_length=20)print(output2)# 5 使用模型進行預測my_model.eval()  # 開啟模型預測驗證result = my_model(output1)print(result)result2 = my_model(output1, return_dict=False)print(result2)# 結果分析topv, topi = torch.topk(result.logits, k=1, 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_tensors='pt',truncation=True,padding='max_length',  # 不夠就補0max_length=20,)# 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_tensors='pt')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對 進行統(tǒng)一合并編碼inputs = my_tokenizer.encode_plus(question, context, return_tensors='pt')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_tensors='pt')# 5 將數據送入模型，進行解碼my_model.eval()outputs = my_model.generate(inputs['input_ids'])print(outputs)# skip_special_tokens=True 跳過特殊符號 BERT的特殊符號 CLS SEP PAD UNK MASK# clean_up_tokenization_spaces=False 是否清理空字符res = my_tokenizer.decode(outputs[0], skip_special_tokens=True, clean_up_tokenization_spaces=True)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_tensors='pt')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 = []# 循環(huán)遍歷 具體的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 如果直接傳入數據文件路徑，直接寫死 split='train' 沒有意義了情況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_files=my_files, split='train')print(train_dataset[0])# 測試集test_dataset = load_dataset('csv', data_files=my_files, split='test')# 驗證集valid_dataset = load_dataset('csv', data_files=my_files, split='valid')return train_dataset, test_dataset, valid_dataset

<四>、對同一批次的數據做標準化

# 4 自定義批處理函數, 對一個批次的數據做標準化
def collate_fn(data):# data=[{text:xxx, label:1}, {},{},,,]# 主要作用：對句子長度進行規(guī)范化，規(guī)范到統(tǒng)一的標準長度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,# 是否截斷truncation=True,# paddingpadding='max_length',max_length=500,# 返回tensor，默認列表return_tensors='pt',# 返回長度return_length=True)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', split='train')my_dataloader = DataLoader(train_dataset,batch_size=8,  # 一個 batch 有 8 條樣本shuffle=True,  # 將數據打亂collate_fn=collate_fn,  # 批處理函數，統(tǒng)一句子長度drop_last=True,  # 刪除最后一個不足一個 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_ids=input_ids,attention_mask=attention_mask,token_type_ids=token_type_ids)output = self.linear(bert_output.pooler_output)  # 可以不做 softmax，后續(xù)有嵌套return output

<七>、模型訓練

# 7 模型訓練
def train_model():# 1 準備物料: 模型、損失函數、優(yōu)化器、數據my_model = MyModel().to(device)# 把bert參數固定住for param in bert_model.parameters():param.requires_grad_(False)# CrossEntropyLoss 本身自帶 softmaxmy_loss_fn = nn.CrossEntropyLoss(reduction='mean')my_adamw = AdamW(my_model.parameters(), lr=3e-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, start=1):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', split='train')test_dataloader = DataLoader(test_dataset,batch_size=8,shuffle=True,collate_fn=collate_fn,drop_last=True,)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, start=1):# 數據放到 with torch.no_grad() 執(zhí)行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_tokens=True)print('當前batch第一個原始文本：', text)print('模型的預測結果', temp[0])print('真是結果是：', labels[0])print('模型總的acc：', correct / total)