自然語言處理 Paddle NLP
2023-06-12 12:01:19
詞向量（Word embedding），即把詞語表示成實數向量。「好」的詞向量能體現詞語直接的相近關係。詞向量已經被證明可以提高NLP任務的效能，例如語法分析和情感分析。
PaddleNLP已預置多個公開的預訓練Embedding，您可以通過使用paddlenlp.embeddings.TokenEmbedding介面載入各種預訓練Embedding。本篇教學將介紹paddlenlp.embeddings.TokenEmbedding的使用方法，計算詞與詞之間的語意距離，並結合詞袋模型獲取句子的語意表示。
字典：有字，有索引（位置編碼），就構成了一個字典，如下表
調詞向量，是通過編碼，去查詞向量矩陣，通過 0 查到 人們
| 字 | 位置編碼 |
|---|---|
| 人們 | 0 |
| 二 | 1 |
| 3 | 2 |
| 預訓練模型中的字典，會和這邊介紹的有所不同，分詞後可能會變成拆開的 | |
| 字 | 位置編碼 |
| ------------ | ------------ |
| 人 | 0 |
| 們 | 1 |
| 二 | 2 |
| 3 | 3 |
載入TokenEmbedding
TokenEmbedding()引數
embedding_name
將模型名稱以引數形式傳入TokenEmbedding，載入對應的模型。預設為w2v.baidu_encyclopedia.target.word-word.dim300的詞向量。unknown_token
未知token的表示，預設為[UNK]。unknown_token_vector
未知token的向量表示，預設生成和embedding維數一致，數值均值為0的正態分佈向量。extended_vocab_path
擴充套件詞彙列表檔案路徑，詞表格式為一行一個詞。如引入擴充套件詞彙列表，trainable=True。trainable
Embedding層是否可被訓練。True表示Embedding可以更新引數，False為不可更新。預設為True。
https://gitee.com/paddlepaddle/PaddleNLP/blob/develop/paddlenlp/embeddings/token_embedding.py
def __init__(
self,
embedding_name=EMBEDDING_NAME_LIST[0], # 詞向量名字
unknown_token=UNK_TOKEN,
unknown_token_vector=None,
extended_vocab_path=None,
trainable=True,
keep_extended_vocab_only=False,
):
...
# 是否要進行梯度更新，預設不做
def set_trainable(self, trainable):
# 查詢詞向量
def search(self, words):
# 通過詞，找對應的ID
def get_idx_from_word(self, word):
# 餘弦相似度
def cosine_sim(self, word_a, word_b):
w2v.baidu_encyclopedia.target.word-word.dim300 左右方向 300，上下方向：3萬個
300維，每個詞對應的詞向量，訓練詞向量時，設定好的引數，如果設定200維，訓練出來的所有詞的詞向量都是200維，將詞壓縮到300維空間做Embedding嵌入方式表徵得到的結果。
300維這個數位是經驗得來的，比較大，相對準一些，如果追求速度，就用100維的
Token: 比如打一句話，把它拆成中文能理解的一個個詞，這個詞就是一個Token，如果拆成一個字一個字，字就是 Token，NLP裡就是這麼叫的。專業詞彙
常用的分詞工具：jieba、IAC（百度）
醫療、法律，不建議使用訓練好的通用詞向量，需要自己去訓練，會達到意想不到的效果
# TokenEmbedding => 向量矩陣 Skip-gram 中的 訓練好的 W
from paddlenlp.embeddings import TokenEmbedding
# 初始化TokenEmbedding， 預訓練embedding未下載時會自動下載並載入資料
# 中英文混雜比較厲害時不建議使用 訓練好的詞向量 `w2v.baidu_encyclopedia.target.word-word.dim300`，如果有就能調到如果沒有就UNK，所以需要自己去訓練
# https://gitee.com/paddlepaddle/PaddleNLP/blob/develop/paddlenlp/embeddings/constant.py
token_embedding = TokenEmbedding(embedding_name="w2v.baidu_encyclopedia.target.word-word.dim300")
# 檢視token_embedding詳情
print(token_embedding)
認識一下Embedding
TokenEmbedding.search()
獲得指定詞彙的詞向量。
test_token_embedding = token_embedding.search("中國")
print(test_token_embedding)
# 300維向量
[[ 0.260801 0.1047 0.129453 -0.257317 -0.16152 0.19567 -0.074868
0.361168 0.245882 -0.219141 -0.388083 0.235189 0.029316 0.154215
-0.354343 0.017746 0.009028 0.01197 -0.121429 0.096542 0.009255
0.039721 0.363704 -0.239497 -0.41168 0.16958 0.261758 0.022383
...
0.123634 0.282932 0.140399 -0.076253 -0.087103 0.07262 ]]
TokenEmbedding.cosine_sim()
計算詞向量間餘弦相似度，語意相近的詞語餘弦相似度更高，說明預訓練好的詞向量空間有很好的語意表示能力。
# 查詢兩個詞之間的相似距離，向量的餘弦夾角
score1 = token_embedding.cosine_sim("女孩", "女人")
score2 = token_embedding.cosine_sim("女孩", "書籍")
print('score1:', score1)
print('score2:', score2)
# 應用場景：輸入法，
# （搜尋、論文查重，是通過現有詞向量，再做句子的表徵，這樣才能做句子和句子之間的匹配）
score1: 0.7017183
score2: 0.19189896
詞向量對映到低維空間
使用深度學習視覺化工具VisualDL的High Dimensional元件可以對embedding結果進行視覺化展示，便於對其直觀分析，步驟如下：
- 升級 VisualDL 最新版本。
pip install --upgrade visualdl
-
建立LogWriter並將記錄詞向量。
-
點選左側面板中的視覺化tab，選擇‘token_hidi’作為檔案並啟動VisualDL視覺化
# 獲取詞表中前1000個單詞
labels = token_embedding.vocab.to_tokens(list(range(0, 1000)))
# 取出這1000個單詞對應的Embedding
test_token_embedding = token_embedding.search(labels)
# 引入VisualDL的LogWriter記錄紀錄檔
from visualdl import LogWriter
with LogWriter(logdir='./token_hidi') as writer:
writer.add_embeddings(tag='test', mat=[i for i in test_token_embedding], metadata=labels)
啟動VisualDL檢視詞向量降維效果
啟動步驟：
- 1、切換到「視覺化」指定視覺化紀錄檔
- 2、紀錄檔檔案選擇 'token_hidi'
- 3、點選「啟動VisualDL」後點選「開啟VisualDL」，選擇「高維資料對映」，即可檢視詞表中前1000詞UMAP方法下對映到三維空間的視覺化結果:
可以看出，語意相近的詞在詞向量空間中聚集(如數位、章節等)，說明預訓練好的詞向量有很好的文字表示能力。
使用VisualDL除視覺化embedding結果外，還可以對標量、圖片、音訊等進行視覺化，有效提升訓練調參效率。關於VisualDL更多功能和詳細介紹，可參考VisualDL使用檔案。
基於TokenEmbedding衡量句子語意相似度
在許多實際應用場景（如檔案檢索系統）中， 需要衡量兩個句子的語意相似程度。此時我們可以使用詞袋模型（Bag of Words，簡稱BoW）計算句子的語意向量。
首先，將兩個句子分別進行切詞，並在TokenEmbedding中查詢相應的單詞詞向量（word embdding）。
然後，根據詞袋模型，將句子的word embedding疊加作為句子向量（sentence embedding）。
最後，計算兩個句子向量的餘弦相似度。
相對於RNN,CNN，用詞向量構造的句子表徵有哪些優點：
- 快、簡單
- 最重要的一點，詞向量是預訓練好的，是一種無監督的表達，並沒有經過任何訓練，很快就能做一個無監督的表徵。用RNN、CNN，需要做標註，需要去訓練，才能讓一個模型穩定
在做一些相似度問題的時候，不管是檢索還是其它搜尋等等應用場景，做句子和句子匹配的一些相似度問題時，都可以分成兩步
- 做一個粗召回，用無監督的方式，快速排個前100
- 再用一些訓練好的匹配模型RNN等，再精排前10名
基於TokenEmbedding的詞袋模型
使用BoWEncoder搭建一個BoW模型用於計算句子語意。
paddlenlp.TokenEmbedding組建word-embedding層paddlenlp.seq2vec.BoWEncoder組建句子建模層，最簡單，最快速的構建方式，常見的建模方式
PaddleNLP 已封裝了下列模型
https://gitee.com/paddlepaddle/PaddleNLP/blob/develop/paddlenlp/seq2vec/encoder.py
__all__ = ["BoWEncoder", "CNNEncoder", "GRUEncoder", "LSTMEncoder", "RNNEncoder", "TCNEncoder"]
原始碼解讀：
import paddle
import paddle.nn as nn
import paddlenlp
class BoWModel(nn.Layer):
def __init__(self, embedder):
super().__init__()
self.embedder = embedder # TokenEmbedding 300的詞向量
emb_dim = self.embedder.embedding_dim
self.encoder = paddlenlp.seq2vec.BoWEncoder(emb_dim) # 把 300 維度傳進去，進行初始化，詞帶模型就搭好了。
self.cos_sim_func = nn.CosineSimilarity(axis=-1) # 餘弦相似度的計算公式
# 判斷兩個句子的相似度
def get_cos_sim(self, text_a, text_b):
text_a_embedding = self.forward(text_a) #句子A的向量
text_b_embedding = self.forward(text_b) #句子B的向量
cos_sim = self.cos_sim_func(text_a_embedding, text_b_embedding) # 餘弦相似度計算
return cos_sim
# 模型資料扭轉方式
def forward(self, text):
# 南哥來聽課，南哥：1、來：3、聽課：7、冒號：0 => text = 1 3 7 0
# batch_size = N 句話
# Shape: (batch_size, num_tokens, embedding_dim)
# 資料進來先過哪個層（上面定義好的 embedding 層
embedded_text = self.embedder(text)
# embedded_text 張量 => [[1對應300維的向量] [3對應300維的向量] [7對應300維的向量] [0對應300維的向量]]
# Shape: (batch_size, embedding_dim)
summed = self.encoder(embedded_text)
# 最終形成句子表徵
return summed
# 模型的初始化（實類化）
model = BoWModel(embedder=token_embedding)
def forward(self, inputs, mask=None):
....
# Shape: (batch_size, embedding_dim)
# 沿著axis = 1 軸方向求和 ,就是將 1的位置相加、2的位置相加....、300的位置相加，得到整個句子的句向量
# 用詞帶的方式得到句子向量的表徵，表達的句子簡單些，想更準確些，可以加一下 tfidf 權重因子
summed = inputs.sum(axis=1)
return summed
class RNNEncoder(nn.Layer):
...
encoded_text, last_hidden = self.rnn_layer(inputs, sequence_length=sequence_length)
if not self._pooling_type:
# We exploit the `last_hidden` (the hidden state at the last time step for every layer)
# to create a single vector.
# If rnn is not bidirection, then output is the hidden state of the last time step
# at last layer. Output is shape of `(batch_size, hidden_size)`.
# If rnn is bidirection, then output is concatenation of the forward and backward hidden state
# of the last time step at last layer. Output is shape of `(batch_size, hidden_size * 2)`.
if self._direction != "bidirect":
output = last_hidden[-1, :, :]
else:
output = paddle.concat((last_hidden[-2, :, :], last_hidden[-1, :, :]), axis=1)
else:
# We exploit the `encoded_text` (the hidden state at the every time step for last layer)
# to create a single vector. We perform pooling on the encoded text.
# The output shape is `(batch_size, hidden_size * 2)` if use bidirectional RNN,
# otherwise the output shape is `(batch_size, hidden_size * 2)`.
# 池化層的操作
if self._pooling_type == "sum": # 求和池化
output = paddle.sum(encoded_text, axis=1)
elif self._pooling_type == "max": # 最大池化
output = paddle.max(encoded_text, axis=1)
elif self._pooling_type == "mean": # 平均池化
output = paddle.mean(encoded_text, axis=1)
else:
raise RuntimeError(
"Unexpected pooling type %s ."
"Pooling type must be one of sum, max and mean." % self._pooling_type
)
return output
構造Tokenizer
data.py
import numpy as np
import jieba
import paddle
from collections import defaultdict
from paddlenlp.data import JiebaTokenizer, Pad, Stack, Tuple, Vocab
class Tokenizer(object):
def __init__(self):
self.vocab = {}
self.tokenizer = jieba
self.vocab_path = 'vocab.txt'
self.UNK_TOKEN = '[UNK]'
self.PAD_TOKEN = '[PAD]'
def set_vocab(self, vocab):
self.vocab = vocab
self.tokenizer = JiebaTokenizer(vocab)
def build_vocab(self, sentences):
word_count = defaultdict(lambda: 0)
for text in sentences:
words = jieba.lcut(text)
for word in words:
word = word.strip()
if word.strip() !='':
word_count[word] += 1
word_id = 0
for word, num in word_count.items():
if num < 5:
continue
self.vocab[word] = word_id
word_id += 1
self.vocab[self.UNK_TOKEN] = word_id
self.vocab[self.PAD_TOKEN] = word_id + 1
self.vocab = Vocab.from_dict(self.vocab,
unk_token=self.UNK_TOKEN, pad_token=self.PAD_TOKEN)
# dump vocab to file
self.dump_vocab(self.UNK_TOKEN, self.PAD_TOKEN)
self.tokenizer = JiebaTokenizer(self.vocab)
return self.vocab
def dump_vocab(self, unk_token, pad_token):
with open(self.vocab_path, "w", encoding="utf8") as f:
for word in self.vocab._token_to_idx:
f.write(word + "\n")
def text_to_ids(self, text):
input_ids = []
unk_token_id = self.vocab[self.UNK_TOKEN]
for token in self.tokenizer.cut(text):
token_id = self.vocab.token_to_idx.get(token, unk_token_id)
input_ids.append(token_id)
return input_ids
def convert_example(self, example, is_test=False):
input_ids = self.text_to_ids(example['text'])
if not is_test:
label = np.array(example['label'], dtype="int64")
return input_ids, label
else:
return input_ids
def create_dataloader(dataset,
trans_fn=None,
mode='train',
batch_size=1,
pad_token_id=0):
"""
Creats dataloader.
Args:
dataset(obj:`paddle.io.Dataset`): Dataset instance.
mode(obj:`str`, optional, defaults to obj:`train`): If mode is 'train', it will shuffle the dataset randomly.
batch_size(obj:`int`, optional, defaults to 1): The sample number of a mini-batch.
pad_token_id(obj:`int`, optional, defaults to 0): The pad token index.
Returns:
dataloader(obj:`paddle.io.DataLoader`): The dataloader which generates batches.
"""
if trans_fn:
dataset = dataset.map(trans_fn, lazy=True)
shuffle = True if mode == 'train' else False
sampler = paddle.io.BatchSampler(
dataset=dataset, batch_size=batch_size, shuffle=shuffle)
batchify_fn = lambda samples, fn=Tuple(
Pad(axis=0, pad_val=pad_token_id), # input_ids
Stack(dtype="int64") # label
): [data for data in fn(samples)]
dataloader = paddle.io.DataLoader(
dataset,
batch_sampler=sampler,
return_list=True,
collate_fn=batchify_fn)
return dataloader
使用TokenEmbedding詞表構造Tokenizer。
from data import Tokenizer
tokenizer = Tokenizer() # 分詞
tokenizer.set_vocab(vocab=token_embedding.vocab) # 載入字典
相似句對資料讀取
以提供的樣例資料text_pair.txt為例，該資料檔案每行包含兩個句子。
多項式矩陣左共軛積對偶Sylvester共軛和數學運算元完備引數解 多項式矩陣的左共軛積及其應用
多項式矩陣左共軛積對偶Sylvester共軛和數學運算元完備引數解 退化阻尼對高維可壓縮尤拉方程組經典解的影響
多項式矩陣左共軛積對偶Sylvester共軛和數學運算元完備引數解 Burgers方程基於特徵正交分解方法的數值解法研究
多項式矩陣左共軛積對偶Sylvester共軛和數學運算元完備引數解 有界對稱域上解析函數空間的若干性質
多項式矩陣左共軛積對偶Sylvester共軛和數學運算元完備引數解 基於折積神經網路的影象複雜度研究與應用
多項式矩陣左共軛積對偶Sylvester共軛和數學運算元完備引數解 Cartesian發射機中線性功率放大器的研究
多項式矩陣左共軛積對偶Sylvester共軛和數學運算元完備引數解 CFRP加固WF型樑側扭屈曲的幾何非線性有限元分析
多項式矩陣左共軛積對偶Sylvester共軛和數學運算元完備引數解 基於線性CCD自適應成像的光刻機平臺調平方法研究
多項式矩陣左共軛積對偶Sylvester共軛和數學運算元完備引數解 基於變分貝葉斯理論的影象復原方法研究
text_pairs = {}
with open("text_pair.txt", "r", encoding="utf8") as f:
for line in f:
text_a, text_b = line.strip().split("\t")
if text_a not in text_pairs:
text_pairs[text_a] = []
text_pairs[text_a].append(text_b)
檢視相似語句相關度
for text_a, text_b_list in text_pairs.items():
text_a_ids = paddle.to_tensor([tokenizer.text_to_ids(text_a)])
for text_b in text_b_list:
text_b_ids = paddle.to_tensor([tokenizer.text_to_ids(text_b)])
print("text_a: {}".format(text_a))
print("text_b: {}".format(text_b))
print("cosine_sim: {}".format(model.get_cos_sim(text_a_ids, text_b_ids).numpy()[0]))
print()
text_a: 多項式矩陣左共軛積對偶Sylvester共軛和數學運算元完備引數解
text_b: 多項式矩陣的左共軛積及其應用
cosine_sim: 0.8861938714981079
text_a: 多項式矩陣左共軛積對偶Sylvester共軛和數學運算元完備引數解
text_b: 退化阻尼對高維可壓縮尤拉方程組經典解的影響
cosine_sim: 0.7975839972496033
text_a: 多項式矩陣左共軛積對偶Sylvester共軛和數學運算元完備引數解
text_b: Burgers方程基於特徵正交分解方法的數值解法研究
cosine_sim: 0.8188782930374146
使用VisualDL檢視句子向量
# 引入VisualDL的LogWriter記錄紀錄檔
import numpy as np
from visualdl import LogWriter
# 獲取句子以及其對應的向量
label_list = []
embedding_list = []
for text_a, text_b_list in text_pairs.items():
text_a_ids = paddle.to_tensor([tokenizer.text_to_ids(text_a)])
embedding_list.append(model(text_a_ids).flatten().numpy())
label_list.append(text_a)
for text_b in text_b_list:
text_b_ids = paddle.to_tensor([tokenizer.text_to_ids(text_b)])
embedding_list.append(model(text_b_ids).flatten().numpy())
label_list.append(text_b)
with LogWriter(logdir='./sentence_hidi') as writer:
writer.add_embeddings(tag='test', mat=embedding_list, metadata=label_list)
啟動VisualDL觀察句子向量降維效果
步驟如上述觀察詞向量降維效果一模一樣。
可以看出，語意相近的句子在句子向量空間中聚集(如有關課堂的句子、有關化學描述句子等)。