introduction
Avant de présenter et d'utiliser le modèle de formation pré-BERT et GPT-2 modèles pré-formés, respectivement, la classification des textes et des temps de génération de texte. Nous présenterons le modèle pré-formation XLNet et de l'utiliser pour les temps de reconnaissance des entités nommées.
point de connaissances
- XLNet BERT et l'amélioration de la GPT-2
- la structure du modèle XLNet
- Utiliser les temps de reconnaissance des entités nommées XLNet
En suivant le modèle BERT équipe Google à la mi-2019 et le modèle présenté XLNet . XLNet sur autant que 20 missions ont obtenu des résultats au - delà de l' ORET, également un système de réponse aux questions, le raisonnement du langage naturel, l' analyse des sentiments, le texte de tri et d' autres tâches que les meilleurs résultats actuels.
Voici XLNet à COLLE sur les résultats des tests:
| Modèle | Chemins de fer | QNLI | QQP | RTE | SST-2 | MRPC | Cola | STS-B |
|---|---|---|---|---|---|---|---|---|
| BERT-Large | 86,6 | 92,3 | 91,3 | 70,4 | 93,2 | 88,0 | 60,6 | 90,0 |
| XLNet-Base | 86,8 | 91,7 | 91,4 | 74,0 | 94,7 | 88,2 | 60,2 | 89,5 |
| XLNet-Large | 89,8 | 93,9 | 91,8 | 83,8 | 95,6 | 89,2 | 63,6 | 91,8 |
XLNet BERT et l'amélioration de la GPT-2
lacunes BERT
BERT peut être considéré comme une version améliorée de XLNet, mais il bert il y a beaucoup de différences. Ci-dessous, nous vous expliquerons en détail.
Dans les premiers temps mentionnés, BERT est auto-codage modèle (Autoencoding), il en d' autres termes, il est, BERT pour protéger le modèle linguistique (Masked Model Language) pour les objectifs de formation. La formation modèle d' auto-régression, certains des mots de la phrase d'entrée sera remplacée au hasard avec [MASK]l'étiquette, puis former le modèle pour prédire les mots d'étiquette masqués.
On peut voir deux inconvénients de ce processus:
- Supposé être à tort couverts sont indépendants de chaque mot et le mot est couvert.
- Entrez le pré-formation et réglage fin n'est pas uniforme.
Inconvénients 1 signifie que lorsque faire une prédiction, parce que certains mots sont [MASK]couverts, donc quand la prévision du modèle BERT est couvert par un mot, en ignorant l'influence d' une autre couverture à ses mots. Autrement dit, en supposant que tous les mots ne sont pas couverts par pertinents, évidemment nous savons que cette hypothèse est fausse.
2 fait référence aux lacunes de la pré-formation , nous utilisons l' [MASK]étiquette pour couvrir une partie du mot, et dans le modèle pré-formé réglage fin, nous ne comptez pas utiliser ce label, ce qui a conduit au processus de formation d' avant-match et d'affiner le processus.
Inconvénient de GPT-2
A un moment nous avons introduit, GPT-2 est un modèle d'auto-régression (Autoregressive), qui est prévu par le texte avant ou après le mot à prédire que des informations contextuelles.
Mathématiquement, une séquence de texte X = (x 1, ..., x_t) X = ( X . 1, ..., X ** T ), le modèle autorégressif calcule le produit du mot à prédiction directe \ ( p (x) = \ prod ^ {T} * {t = 1} p (x_t | x * {<t}), dans lequel, lorsque x _ {<t} désigne représente un mot avant x_t de même, le mot prédit. derrière le produit est exprimé en: mot même précédent, mot prédiction arrière peut être exprimée en tant que produit de :. p (x) = \ prod ^ {T} * {t = 1} p (x_t | x * {> t}) \) .
Mais à partir d'un modèle de régression est inconvénient évident est qu'il ne peut considérer le contexte d'une seule direction. Plusieurs fois les tâches en aval, telles que la compréhension du langage naturel, sera également besoin de retour d'information contextuelle et-vient dans les deux sens.
Les lacunes inhérentes à l'introduction du modèle d'auto-codage pour représenter BERT et modèle d'auto-régression de GPT-2 représenté ci-dessous vous expliquera comment améliorer XLNet est réalisée pour les défauts de ces deux types de modèles.
L'amélioration XLNet
Les chercheurs du modèle XLNet de conception, en tenant compte de surmonter les inconvénients du modèle d'auto-codage et le modèle d'auto-régression, et de combiner leurs forces pour concevoir la disposition des modèles de langage (Permutation lanuage Model). Comme on le voit ci-dessous, l'idée est que le système de modèle de langage, puisque le seul moyen d'obtenir le modèle autorégressif contexte linguistique, cela changerait la façon dont les mots sont classés par l'emplacement des deux voies à sens unique des déclarations d'arrangement.
Dans la partie supérieure de droit d'exemple la figure, lorsque l'alignement de mots devient « 2 -> 4 -> 3 -> 1 », et la prédiction de la formation cible trois mots, deux mots pour le modèle d'entrée et le mot 4 informations. Ce modèle conserve les caractéristiques du modèle d'auto-régression, mais aussi de faire un modèle d'apprentissage dans les deux sens de l'information contextuelle.
Notez que la modification de la disposition ne modifie pas les termes de l'information de localisation qui est venu dans le troisième mot de vecteur de position ou les mots seraient les troisièmes bits d'information.
Dans la mise en œuvre spécifique, par l'action de l'un des masques est mécanisme d'attention variée de modifier l'objet de l'arrangement, la partie de cadre rouge peut se référer au schéma,
D'autres parties du sens de ce chiffre expliquer ci-dessous, ici pour parler de la partie de la boîte rouge. La seconde moitié du comportement du mode de réalisation ci-dessus, lorsqu'il est exprimé sur le mot suivant deux prédiction de mot, un masque est ajouté à chaque mot, et à ce moment l'ordre est « 3 -> 2 -> 4 -> 1. » Ainsi, lorsqu'il est ajouté au mot valeur de masque 2 et 3 devraient être 1, vous pouvez voir la représentation du modèle de parole de la valeur de la durée restante doit être nul. Nous pouvons également voir la figure dans la deuxième rangée et trois secondes masque correspondant sont marqués en rouge. Autre ligne la moitié supérieure de l'empathie.
Les chiffres différents dans la moitié inférieure est la moitié inférieure du masque peut être ajouté afin que le modèle ne peut pas voir chaque mot à prévoir, tels que les modèles de prévision du modèle ont le mot aurait pas vu le mot en question 2 02h00.
la structure du modèle XLNet
Méthode de segmentation SentencePiece
modèle XLNet utilise SentencePiece méthode de segmentation, SentencePiece est la boîte à outils de traitement du langage naturel open-source de Google. Son principe est le plus souvent les statistiques apparaissent fragment, est considéré comme le fragment d'un mot.
outil SentencePiece est unique en ce qu'elle ne vous fiez pas à la formation avant, mais en mettant l'accent sur l'apprentissage de la formation donnée, et il ne sera pas à cause des langues différentes et ont des performances différentes, car il traite tous les caractères de la chaîne considéré comme un caractère Unicode.
On peut dire d'optimiser l'utilisation méthode SentencePiece BERT WordPiece utilisé pour les problèmes de mot chinois de mauvaise performance.
mécanisme d'auto-attention Shuangliu
Sur toute la structure, les différences structurelles de la structure du modèle XLNet BERT et peu, sont basés sur transformateur basé. Cependant modèle XLNet utilise un mécanisme spécial d'attention, à savoir de doubles mécanismes attentionnels (Deux-Stream auto-attention), XLNet attention de la double mécanisme utilise Caractériser les deux unités, respectivement, et le contenu de l'unité de caractérisation d'interrogation jeton .
Est une unité qui caractérise le contenu des informations ci-dessus, contiendra le mot courant. Caractérisation de l'unité d'information d'interrogation comprend des informations indiquant le mot courant autre que ci-dessus, et les informations de position, y compris le mot en cours et ne peut pas accéder à l'information de contenu du mot courant.
Caractérisation Caractérisation unité d'interrogation contenu et deux unités de flux d'informations, à la fois le flux continu d'informations transmises haut, les informations de sortie à la fin de l'unité d'interrogation. On peut voir à partir de la ligne rouge et la partie inférieure de la figure., De même que le résultat prévu de la sortie finale correspondant à l'ordre des mots d'entrée.
Le regard détaillé ci-dessous à chaque partie de ce chiffre, la première figure (a) indique la partie de l'attention du flux de contenu (attention de flux de contenu), une partie d'un diagramme montrant (b) est de demander le flux d'attention (l'attention de flux de requête). On peut voir sur la figure. (B) un seul mot correspondant unité d'interrogation de caractérisation est entrée, alors que sur la figure. (A), le contenu du mot 1 a le jeton est entrée. Section diagramme montrant (c) comment le modèle est appliqué à partir des mécanismes d'attention Shuangliu. Et. La figure (C) est le masque de mise au point à droite, nous avons décrit plus haut. Ajouter un effet de masque en plus d'atteindre le but de modifier l'arrangement, a également atteint l'attention du modèle dans le flux de contenu peut être vu dans le mot en cours, et l'attention ne peut pas voir le but de demander l'écoulement du mot courant.
En plus de la méthode mentionnée ci-dessus, XLNet utilisent également une manière prévisible, parce que le modèle autorégressif de langue est prédite à partir du premier mot au dernier mot, mais dans la prévision de la phase initiale, en raison du modèle d'information de déclaration moins connue 1 / K après un mot est difficile à converger, seule la prédiction réelle partie d'instruction sélectionnée de l'avant et 1-1 / K en tant que des informations de contexte.
reconnaissance d'entités nommées XLNet
Au-dessus, nous avons décrit dans certaines méthodes spéciales XLNet BERT et GPT-2 sur la base de l'amélioration et le modèle XLNet utilisé. Ensuite, nous utiliserons le modèle de pré-formation XLNet ont été nommés les temps de reconnaissance de l'entité. NER (reconnaissance d'entités nommées, NER mentionné), sont des entités qui ont une signification particulière dans le texte reconnu, y compris les noms de lieux, noms d'organisation et d'autres noms propres. reconnaissance d'entités nommées est une étape importante dans l'extraction de l'information, et est largement utilisé dans le traitement du langage naturel.
La seconde sources de données et de test de formation que nous utilisons pour CoNLL-2003 , ensemble de données CoNLL-2003 est basée sur corpus de nouvelles, a marqué quatre entités, à savoir: les entreprises, les lieux et les noms ne appartiennent aux catégories ci - dessus trois entité. Nommé ORG, LOC, PER, MISC, le premier mot est une entité marquée B-ORG, B-LOC, B-PER, B-MISC, deuxième mot étiqueté I-ORG, I-LOC, I-PER, I-MISC, étiqueté Omot indique qu'il ne fais partie d'aucun d'une phrase.
nous utiliserons ici la bibliothèque de modèles PyTorch-transformateurs emballé XLNetTokenizer()et XLNetModelclasse pour mener effectivement une application de modèle de pré-formation XLNet. Tout d' abord, vous devez installer PyTorch-transformateurs.
!pip install pytorch-transformers==1.0 # 安装 PyTorch-Transformers
Étant donné que la structure de données d'origine est plus complexe, nous avons donc dû actualiser les données à l'avance, les données ont été étiquetés conformément à l'étiquette suivante.
# 标签数据所对应的字符串含义
label_dict = {'O':0, 'B-ORG':1, 'I-ORG':2, 'B-PER':3, 'I-PER':4, 'B-LOC':5, 'I-LOC':6, 'B-MISC':7, 'I-MISC':8, 'X':9, '[PAD]':10}
On peut noter dans l'étiquette ci - dessus plus Xet [PAD]balises, leurs significations sont: parce que mot fera un mot complet d' origine au large, et la section supplémentaire nous partîmes l'étiquette X. [PAD]Correspondant à l'étiquette est de remplir les caractères.
A côté de télécharger l'ensemble de données a été téléchargé à l' avance, lien disque réseau: https://pan.baidu.com/s/18jqTwLNM2Vmf7fOzkh7UgA Code d'extraction: zko3
Une fois que vous avez téléchargé l'ensemble de données, lire les fichiers de données.
train_samples = []
train_labels = []
with open('./train.txt', 'r') as f:
while True:
s1 = f.readline()
if not s1:
# 如果读取到内容为空，则读取结束
break
s2 = f.readline()
_ = f.readline()
train_samples.append(s1.replace('\n', ''))
train_labels.append(s2.replace('\n', ''))
len(train_samples), len(train_labels)
En raison de ce qui précède, faire un mot mot complet au large, donc après le mot, nous voulons augmenter encore l'étiquette dans la base de données d' origine. Par exemple , le mot « Elle », sont classés en « Elle », « « », « s », trois mots, le mot sera l'original correspondant à l'étiquette « de Elle » Omarquée sur le mot, « Elle », et « » » , "s" pour les tables, respectivement X, et X. Le code suivant est réalisé pour modifier la balise.
from pytorch_transformers import XLNetTokenizer
# 使用 XLNet 的分词器
tokenizer = XLNetTokenizer.from_pretrained('xlnet-base-cased')
input_ids = []
input_labels = []
for text, ori_labels in zip(train_samples, train_labels):
l = text.split(' ')
labels = []
text_ids = []
for word, label in zip(l, ori_labels):
if word == '':
continue
tokens = tokenizer.tokenize(word)
for i, j in enumerate(tokens):
if i == 0:
labels.append(int(label))
text_ids.append(tokenizer.convert_tokens_to_ids(j))
else:
labels.append(9)
text_ids.append(tokenizer.convert_tokens_to_ids(j))
input_ids.append(text_ids)
input_labels.append(labels)
len(input_ids), len(input_labels)
Après avoir préparé les données utilisées ici PyTorch offert DataLoader()pour construire une formation ensemble de données que l'utilisation de la TensorDataset()construction des données de formation iterator.
import torch
from torch.utils.data import DataLoader, TensorDataset
del train_samples
del train_labels
for j in range(len(input_ids)):
# 将样本数据填充至长度为 128
i = input_ids[j]
if len(i) != 128:
input_ids[j].extend([0]*(128 - len(i)))
for j in range(len(input_labels)):
# 将样本数据填充至长度为 128
i = input_labels[j]
if len(i) != 128:
input_labels[j].extend([10]*(128 - len(i)))
# 构建数据集和数据迭代器，设定 batch_size 大小为 8
train_set = TensorDataset(torch.LongTensor(input_ids),
torch.LongTensor(input_labels))
train_loader = DataLoader(dataset=train_set,
batch_size=8,
shuffle=True)
train_loader
Vérifiez si la machine a GPU, si vous exécutez GPU, sinon le CPU est en cours d'exécution.
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device
En raison du grand volume XLNet pré-modèle, et hébergé en dehors du réseau, alors commencez avec le site Web pour télécharger le modèle de pré-formation. Liens: https://pan.baidu.com/s/1CySwfsOyh9Id4T85koxAeg Code extraction: lah0
Les classes suivantes construits pour la reconnaissance de l' entité appelée, la reconnaissance de l' entité appelée est réalisée essentiellement modèle de classification XLNet ajouté à une Dropoutcouche pour empêcher surajustement et une Linearcouche reliée à fond.
import torch.nn as nn
from pytorch_transformers import XLNetModel
class NERModel(nn.Module):
def __init__(self, num_class=11):
super(NERModel, self).__init__()
# 读取 XLNet 预训练模型
self.model = XLNetModel.from_pretrained("./")
self.dropout = nn.Dropout(0.1)
self.l1 = nn.Linear(768, num_class)
def forward(self, x, attention_mask=None):
outputs = self.model(x, attention_mask=attention_mask)
x = outputs[0] # 形状为 batch * seqlen * 768
x = self.dropout(x)
x = self.l1(x)
return x
fonction de perte définie. Tel qu'il est utilisé ici, le entropie croisée (Cross Entropy) comme une fonction de perte.
def loss_function(logits, target, masks, num_class=11):
criterion = nn.CrossEntropyLoss(reduction='none')
logits = logits.view(-1, num_class)
target = target.view(-1)
masks = masks.view(-1)
cross_entropy = criterion(logits, target)
loss = cross_entropy * masks
loss = loss.sum() / (masks.sum() + 1e-12) # 加上 1e-12 防止被除数为 0
loss = loss.to(device)
return loss
classe entité, définie fonction de perte, établir l'optimiseur.
from torch.optim import Adam
model = NERModel()
model.to(device)
model.train()
optimizer = Adam(model.parameters(), lr=1e-5)
Commencer la formation.
from torch.autograd import Variable
import time
pre = time.time()
epoch = 3
for i in range(epoch):
for batch_idx, (data, target) in enumerate(train_loader):
data, target = Variable(data).to(device), Variable(target).to(device)
optimizer.zero_grad()
# 生成掩膜
mask = []
for sample in data:
mask.append([1 if i != 0 else 0 for i in sample])
mask = torch.FloatTensor(mask).to(device)
output = model(data, attention_mask=mask)
# 得到模型预测结果
pred = torch.argmax(output, dim=2)
loss = loss_function(output, target, mask)
loss.backward()
optimizer.step()
if ((batch_idx+1) % 10) == 1:
print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss:{:.6f}'.format(
i+1, batch_idx, len(train_loader), 100. *
batch_idx/len(train_loader), loss.item()
))
if batch_idx == len(train_loader)-1:
# 在每个 Epoch 的最后输出一下结果
print('labels:', target)
print('pred:', pred)
print('训练时间：', time.time()-pre)
Après la formation, vous pouvez être utilisé pour vérifier l'effet de l'ensemble de la formation pour observer le modèle.
Construction et ensembles de données de validation lisent les données iterator même manière que l'ensemble de la formation.
eval_samples = []
eval_labels = []
with open('./dev.txt', 'r') as f:
while True:
s1 = f.readline()
if not s1:
break
s2 = f.readline()
_ = f.readline()
eval_samples.append(s1.replace('\n', ''))
eval_labels.append(s2.replace('\n', ''))
len(eval_samples)
# 这里使用和训练集同样的方式修改标签，不再赘述
input_ids = []
input_labels = []
for text, ori_labels in zip(eval_samples, eval_labels):
l = text.split(' ')
labels = []
text_ids = []
for word, label in zip(l, ori_labels):
if word == '':
continue
tokens = tokenizer.tokenize(word)
for i, j in enumerate(tokens):
if i == 0:
labels.append(int(label))
text_ids.append(tokenizer.convert_tokens_to_ids(j))
else:
labels.append(9)
text_ids.append(tokenizer.convert_tokens_to_ids(j))
input_ids.append(text_ids)
input_labels.append(labels)
del eval_samples
del eval_labels
for j in range(len(input_ids)):
# 将样本数据填充至长度为 128
i = input_ids[j]
if len(i) != 128:
input_ids[j].extend([0]*(128 - len(i)))
for j in range(len(input_labels)):
# 将样本数据填充至长度为 128
i = input_labels[j]
if len(i) != 128:
input_labels[j].extend([10]*(128 - len(i)))
# 构建数据集和数据迭代器，设定 batch_size 大小为 1
eval_set = TensorDataset(torch.LongTensor(input_ids),
torch.LongTensor(input_labels))
eval_loader = DataLoader(dataset=eval_set,
batch_size=1,
shuffle=False)
eval_loader
Le modèle est réglé sur le mode d'authentification, ensemble de données de validation d'entrée.
from tqdm import tqdm_notebook as tqdm
model.eval()
correct = 0
total = 0
for batch_idx, (data, target) in enumerate(tqdm(eval_loader)):
data = data.to(device)
target = target.float().to(device)
# 生成掩膜
mask = []
for sample in data:
mask.append([1 if i != 0 else 0 for i in sample])
mask = torch.Tensor(mask).to(device)
output = model(data, attention_mask=mask)
# 得到模型预测结果
pred = torch.argmax(output, dim=2)
# 将掩膜添加到预测结果上，便于计算准确率
pred = pred.float()
pred = pred * mask
target = target * mask
pred = pred[:, 0:mask.sum().int().item()]
target = target[:, 0:mask.sum().int().item()]
correct += (pred == target).sum().item()
total += mask.sum().item()
print('正确分类的标签数：{}，标签总数：{}，准确率：{:.2f}%'.format(
correct, total, 100.*correct/total))
On peut voir le taux final de précision supérieur à 90%. Dans l'extraction d'entités d'application, et parfois extrait en ajoutant le mot d'entité de règles ou seront remplacées lorsque les dernières prévisions couche Softmax marquées CRFs améliorer la précision, étant donné que le contenu ne soit pas au centre du temps, les étudiants intéressés peuvent être auto apprendre à trouver des informations.
résumé
À ce moment, nous savons que le BERT et version améliorée XLNet GPT-2, qui combine les avantages des deux modèles, qui ne présente pas l'étiquette de masquage du bruit produit sans problèmes de formation et de réglage fin d'avant-match, et peut en même temps l'intégration du contexte de l'information contextuelle. Ensuite, nous avons été les temps de NER XLNet, a été une bonne performance.
Liens connexes