[PYTHON] [PyTorch] Introduction à la classification de documents à l'aide de BERT
introduction
Dans cet article, nous allons suivre le processus de mise au point d'un modèle BERT pré-formé à travers la tâche de catégoriser les en-têtes d'articles de presse en anglais. Dans le cas du japonais, contrairement à l'anglais, une analyse morphologique est nécessaire, mais le flux global est le même que le contenu de cet article.
De plus, cette implémentation est également la réponse à la question 89 de 100 language processing knock 2020 version. Pour obtenir des exemples de réponses à d'autres questions, consultez [Knock 100 Language Processing 2020] Résumé des exemples de réponses en Python.
Préparation préalable
Google Colaboratory est utilisé pour la mise en œuvre. Pour plus d'informations sur la configuration et l'utilisation de Google Colaboratory, consultez [cet article](https: // cpp-fu learning.com/python_colaboratory/). ** Si vous souhaitez utiliser le GPU pour la reproduction, veuillez changer l'accélérateur matériel sur "GPU" à partir de "Runtime" -> "Changer le type d'exécution" et enregistrez-le à l'avance. ** ** Le cahier contenant les résultats d'exécution est disponible sur github.
Classification des documents par BERT
Les en-têtes des articles de presse utilisant les données publiques News Aggregator Data Set sont "Business", "Science and Technology" et "Entertainment". Nous mettrons en œuvre un modèle de classification des documents par BERT pour les tâches qui entrent dans la catégorie «santé».
Lire les données
Tout d'abord, téléchargez les données cibles.
!wget https://archive.ics.uci.edu/ml/machine-learning-databases/00359/NewsAggregatorDataset.zip
!unzip NewsAggregatorDataset.zip
#Vérifiez le nombre de lignes
!wc -l ./newsCorpora.csv
production
422937 ./newsCorpora.csv
#Vérifiez les 10 premières lignes
!head -10 ./newsCorpora.csv
production
1 Fed official says weak data caused by weather, should not slow taper http://www.latimes.com/business/money/la-fi-mo-federal-reserve-plosser-stimulus-economy-20140310,0,1312750.story\?track=rss Los Angeles Times b ddUyU0VZz0BRneMioxUPQVP6sIxvM www.latimes.com 1394470370698
2 Fed's Charles Plosser sees high bar for change in pace of tapering http://www.livemint.com/Politics/H2EvwJSK2VE6OF7iK1g3PP/Feds-Charles-Plosser-sees-high-bar-for-change-in-pace-of-ta.html Livemint b ddUyU0VZz0BRneMioxUPQVP6sIxvM www.livemint.com 1394470371207
3 US open: Stocks fall after Fed official hints at accelerated tapering http://www.ifamagazine.com/news/us-open-stocks-fall-after-fed-official-hints-at-accelerated-tapering-294436 IFA Magazine b ddUyU0VZz0BRneMioxUPQVP6sIxvM www.ifamagazine.com 1394470371550
4 Fed risks falling 'behind the curve', Charles Plosser says http://www.ifamagazine.com/news/fed-risks-falling-behind-the-curve-charles-plosser-says-294430 IFA Magazine b ddUyU0VZz0BRneMioxUPQVP6sIxvM www.ifamagazine.com 1394470371793
5 Fed's Plosser: Nasty Weather Has Curbed Job Growth http://www.moneynews.com/Economy/federal-reserve-charles-plosser-weather-job-growth/2014/03/10/id/557011 Moneynews b ddUyU0VZz0BRneMioxUPQVP6sIxvM www.moneynews.com 1394470372027
6 Plosser: Fed May Have to Accelerate Tapering Pace http://www.nasdaq.com/article/plosser-fed-may-have-to-accelerate-tapering-pace-20140310-00371 NASDAQ b ddUyU0VZz0BRneMioxUPQVP6sIxvM www.nasdaq.com 1394470372212
7 Fed's Plosser: Taper pace may be too slow http://www.marketwatch.com/story/feds-plosser-taper-pace-may-be-too-slow-2014-03-10\?reflink=MW_news_stmp MarketWatch b ddUyU0VZz0BRneMioxUPQVP6sIxvM www.marketwatch.com 1394470372405
8 Fed's Plosser expects US unemployment to fall to 6.2% by the end of 2014 http://www.fxstreet.com/news/forex-news/article.aspx\?storyid=23285020-b1b5-47ed-a8c4-96124bb91a39 FXstreet.com b ddUyU0VZz0BRneMioxUPQVP6sIxvM www.fxstreet.com 1394470372615
9 US jobs growth last month hit by weather:Fed President Charles Plosser http://economictimes.indiatimes.com/news/international/business/us-jobs-growth-last-month-hit-by-weatherfed-president-charles-plosser/articleshow/31788000.cms Economic Times b ddUyU0VZz0BRneMioxUPQVP6sIxvM economictimes.indiatimes.com 1394470372792
10 ECB unlikely to end sterilisation of SMP purchases - traders http://www.iii.co.uk/news-opinion/reuters/news/152615 Interactive Investor b dPhGU51DcrolUIMxbRm0InaHGA2XM www.iii.co.uk 1394470501265
#Remplacement des guillemets doubles par des guillemets simples pour éviter les erreurs lors de la lecture
!sed -e 's/"/'\''/g' ./newsCorpora.csv > ./newsCorpora_re.csv
Ensuite, lisez-le comme un bloc de données, extrayez uniquement les cas où la source d'informations (PUBLISHER) est Reuters, Huffington Post, Businessweek, Contactmusic.com, Daily Mail, puis divisez-le en données de formation, données de vérification et données d'évaluation.
import pandas as pd
from sklearn.model_selection import train_test_split
#Lire les données
df = pd.read_csv('./newsCorpora_re.csv', header=None, sep='\t', names=['ID', 'TITLE', 'URL', 'PUBLISHER', 'CATEGORY', 'STORY', 'HOSTNAME', 'TIMESTAMP'])
#Extraction de données
df = df.loc[df['PUBLISHER'].isin(['Reuters', 'Huffington Post', 'Businessweek', 'Contactmusic.com', 'Daily Mail']), ['TITLE', 'CATEGORY']]
#Répartition des données
train, valid_test = train_test_split(df, test_size=0.2, shuffle=True, random_state=123, stratify=df['CATEGORY'])
valid, test = train_test_split(valid_test, test_size=0.5, shuffle=True, random_state=123, stratify=valid_test['CATEGORY'])
train.reset_index(drop=True, inplace=True)
valid.reset_index(drop=True, inplace=True)
test.reset_index(drop=True, inplace=True)
print(train.head())
production
TITLE CATEGORY
0 REFILE-UPDATE 1-European car sales up for sixt... b
1 Amazon Plans to Fight FTC Over Mobile-App Purc... t
2 Kids Still Get Codeine In Emergency Rooms Desp... m
3 What On Earth Happened Between Solange And Jay... e
4 NATO Missile Defense Is Flight Tested Over Hawaii b
#Confirmation du nombre de cas
print('[Données d'apprentissage]')
print(train['CATEGORY'].value_counts())
print('[Données de vérification]')
print(valid['CATEGORY'].value_counts())
print('[Données d'évaluation]')
print(test['CATEGORY'].value_counts())
production
[Données d'apprentissage]
b 4501
e 4235
t 1220
m 728
Name: CATEGORY, dtype: int64
[Données de vérification]
b 563
e 529
t 153
m 91
Name: CATEGORY, dtype: int64
[Données d'évaluation]
b 563
e 530
t 152
m 91
Name: CATEGORY, dtype: int64
(b: affaires, e: divertissement, t: science et technologie, m: santé)
Se préparer à l'apprentissage
Installez la bibliothèque transformers '' pour utiliser le modèle BERT. Grâce aux `` transformateurs '', de nombreux modèles pré-entraînés en plus de BERT peuvent être utilisés très facilement avec un code court.
!pip install transformers
Importez les bibliothèques nécessaires pour entraîner et évaluer votre modèle.
import numpy as np
import transformers
import torch
from torch.utils.data import Dataset, DataLoader
from transformers import BertTokenizer, BertModel
from torch import optim
from torch import cuda
import time
from matplotlib import pyplot as plt
Ensuite, façonnez les données sous une forme qui peut être entrée dans le modèle.
Tout d'abord, définissez une classe pour créer un ensemble de données '' qui contient le vecteur de fonction et le vecteur d'étiquette ensemble, ce qui est souvent utilisé dans PyTorch. En passant tokenizer '' à cette classe, il est possible de prétraiter le texte d'entrée, de le remplir à la longueur de série la plus longue spécifiée, puis de le convertir en un identifiant de mot.
Cependant, le tokenizer '' lui-même, où tout le traitement est écrit pour BERT, sera obtenu plus tard via tranformers '', donc ce dont vous avez besoin dans la classe est tokenizer. Seul le processus de passage à ʻet le processus de réception du résultat.
#Définition de l'ensemble de données
class CreateDataset(Dataset):
def __init__(self, X, y, tokenizer, max_len):
self.X = X
self.y = y
self.tokenizer = tokenizer
self.max_len = max_len
def __len__(self): # len(Dataset)Spécifiez la valeur à renvoyer avec
return len(self.y)
def __getitem__(self, index): # Dataset[index]Spécifiez la valeur à renvoyer avec
text = self.X[index]
inputs = self.tokenizer.encode_plus(
text,
add_special_tokens=True,
max_length=self.max_len,
pad_to_max_length=True
)
ids = inputs['input_ids']
mask = inputs['attention_mask']
return {
'ids': torch.LongTensor(ids),
'mask': torch.LongTensor(mask),
'labels': torch.Tensor(self.y[index])
}
Créez un `` ensemble de données '' en utilisant ce qui précède. De plus, BERT qui peut être utilisé comme modèle pré-entraîné en version anglaise est LARGE, qui est une configuration visant la plus grande précision, BASE avec moins de paramètres, et 4 de chacun d'entre eux, uniquement en minuscules (Uncased) et en cas mixte (Cased) Il y a un modèle. Cette fois, nous utiliserons BASE's Uncased, que vous pouvez facilement essayer.
#Corriger l'étiquette un-Chaud
y_train = pd.get_dummies(train, columns=['CATEGORY'])[['CATEGORY_b', 'CATEGORY_e', 'CATEGORY_t', 'CATEGORY_m']].values
y_valid = pd.get_dummies(valid, columns=['CATEGORY'])[['CATEGORY_b', 'CATEGORY_e', 'CATEGORY_t', 'CATEGORY_m']].values
y_test = pd.get_dummies(test, columns=['CATEGORY'])[['CATEGORY_b', 'CATEGORY_e', 'CATEGORY_t', 'CATEGORY_m']].values
#Créer un jeu de données
max_len = 20
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
dataset_train = CreateDataset(train['TITLE'], y_train, tokenizer, max_len)
dataset_valid = CreateDataset(valid['TITLE'], y_valid, tokenizer, max_len)
dataset_test = CreateDataset(test['TITLE'], y_test, tokenizer, max_len)
for var in dataset_train[0]:
print(f'{var}: {dataset_train[0][var]}')
production
ids: tensor([ 101, 25416, 9463, 1011, 10651, 1015, 1011, 2647, 2482, 4341,
2039, 2005, 4369, 3204, 2004, 18730, 8980, 102, 0, 0])
mask: tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0])
labels: tensor([1., 0., 0., 0.])
Les informations de la première phrase sont sorties.
Vous pouvez voir que la chaîne d'entrée a été convertie en une série d'ID en tant que ids. Dans BERT, des délimiteurs spéciaux [CLS] et [SEP] sont insérés au début et à la fin de la phrase originale pendant le processus de conversion, ils sont donc également 101 '' et 102 ''. Inclus dans la série comme `. 0 représente le remplissage. Les étiquettes de réponse correctes sont également conservées dans un format unique en tant que `` étiquettes ''. Aussi, gardez le `` masque qui représente la position de remplissage afin qu'il puisse être passé au modèle avec les `` aides``` pendant l'entraînement.
Ensuite, définissez le réseau.
transfomersEn utilisant, toute la partie bertbertmodelIl peut être exprimé avec. Ensuite, pour faciliter la tâche de classification, définissez un abandon qui reçoit le vecteur de sortie de bert et une couche entièrement connectée, et vous avez terminé.
#Définition du modèle de classification BERT
class BERTClass(torch.nn.Module):
def __init__(self, drop_rate, otuput_size):
super().__init__()
self.bert = BertModel.from_pretrained('bert-base-uncased')
self.drop = torch.nn.Dropout(drop_rate)
self.fc = torch.nn.Linear(768, otuput_size) #Spécifiez 768 dimensions en fonction de la sortie de BERT
def forward(self, ids, mask):
_, out = self.bert(ids, attention_mask=mask)
out = self.fc(self.drop(out))
return out
Apprendre le modèle de classification BERT
Maintenant que vous avez un réseau avec Dataset '', il est temps de créer votre boucle d'apprentissage habituelle. Ici, une série de flux est définie comme une fonction train_model ''. Pour connaître la signification des composants qui apparaissent, consultez le flux du problème dans l'article [Language Processing 100 Knock 2020] Chapitre 8: Neural Net. Veuillez vous référer à l'explication avec elle.
def calculate_loss_and_accuracy(model, criterion, loader, device):
"""Calculer le taux de perte / réponse correcte"""
model.eval()
loss = 0.0
total = 0
correct = 0
with torch.no_grad():
for data in loader:
#Spécification de l'appareil
ids = data['ids'].to(device)
mask = data['mask'].to(device)
labels = data['labels'].to(device)
#Propagation vers l'avant
outputs = model.forward(ids, mask)
#Calcul des pertes
loss += criterion(outputs, labels).item()
#Calcul du taux de réponse correct
pred = torch.argmax(outputs, dim=-1).cpu().numpy() #Tableau d'étiquettes prévu pour la longueur de la taille du lot
labels = torch.argmax(labels, dim=-1).cpu().numpy() #Tableau d'étiquettes correct de la taille du lot
total += len(labels)
correct += (pred == labels).sum().item()
return loss / len(loader), correct / total
def train_model(dataset_train, dataset_valid, batch_size, model, criterion, optimizer, num_epochs, device=None):
"""Exécute la formation du modèle et renvoie un journal du taux de perte / réponse correcte"""
#Spécification de l'appareil
model.to(device)
#Créer un chargeur de données
dataloader_train = DataLoader(dataset_train, batch_size=batch_size, shuffle=True)
dataloader_valid = DataLoader(dataset_valid, batch_size=len(dataset_valid), shuffle=False)
#Apprentissage
log_train = []
log_valid = []
for epoch in range(num_epochs):
#Heure de début d'enregistrement
s_time = time.time()
#Mettre en mode entraînement
model.train()
for data in dataloader_train:
#Spécification de l'appareil
ids = data['ids'].to(device)
mask = data['mask'].to(device)
labels = data['labels'].to(device)
#Initialiser le dégradé à zéro
optimizer.zero_grad()
#Propagation vers l'avant+Erreur de propagation de retour+Mise à jour du poids
outputs = model.forward(ids, mask)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
#Calcul de la perte et taux de réponse correcte
loss_train, acc_train = calculate_loss_and_accuracy(model, criterion, dataloader_train, device)
loss_valid, acc_valid = calculate_loss_and_accuracy(model, criterion, dataloader_valid, device)
log_train.append([loss_train, acc_train])
log_valid.append([loss_valid, acc_valid])
#Enregistrer le point de contrôle
torch.save({'epoch': epoch, 'model_state_dict': model.state_dict(), 'optimizer_state_dict': optimizer.state_dict()}, f'checkpoint{epoch + 1}.pt')
#Enregistrer l'heure de fin
e_time = time.time()
#Journal de sortie
print(f'epoch: {epoch + 1}, loss_train: {loss_train:.4f}, accuracy_train: {acc_train:.4f}, loss_valid: {loss_valid:.4f}, accuracy_valid: {acc_valid:.4f}, {(e_time - s_time):.4f}sec')
return {'train': log_train, 'valid': log_valid}
Définissez les paramètres et effectuez un réglage fin.
#Paramétrage
DROP_RATE = 0.4
OUTPUT_SIZE = 4
BATCH_SIZE = 32
NUM_EPOCHS = 4
LEARNING_RATE = 2e-5
#Définition du modèle
model = BERTClass(DROP_RATE, OUTPUT_SIZE)
#Définition de la fonction de perte
criterion = torch.nn.BCEWithLogitsLoss()
#Définition de l'optimiseur
optimizer = torch.optim.AdamW(params=model.parameters(), lr=LEARNING_RATE)
#Spécification de l'appareil
device = 'cuda' if cuda.is_available() else 'cpu'
#Apprentissage de modèle
log = train_model(dataset_train, dataset_valid, BATCH_SIZE, model, criterion, optimizer, NUM_EPOCHS, device=device)
production
epoch: 1, loss_train: 0.0859, accuracy_train: 0.9516, loss_valid: 0.1142, accuracy_valid: 0.9229, 49.9137sec
epoch: 2, loss_train: 0.0448, accuracy_train: 0.9766, loss_valid: 0.1046, accuracy_valid: 0.9259, 49.7376sec
epoch: 3, loss_train: 0.0316, accuracy_train: 0.9831, loss_valid: 0.1082, accuracy_valid: 0.9266, 49.5454sec
epoch: 4, loss_train: 0.0170, accuracy_train: 0.9932, loss_valid: 0.1179, accuracy_valid: 0.9289, 49.4525sec
Vérifiez le résultat.
#Visualisation du journal
x_axis = [x for x in range(1, len(log['train']) + 1)]
fig, ax = plt.subplots(1, 2, figsize=(15, 5))
ax[0].plot(x_axis, np.array(log['train']).T[0], label='train')
ax[0].plot(x_axis, np.array(log['valid']).T[0], label='valid')
ax[0].set_xlabel('epoch')
ax[0].set_ylabel('loss')
ax[0].legend()
ax[1].plot(x_axis, np.array(log['train']).T[1], label='train')
ax[1].plot(x_axis, np.array(log['valid']).T[1], label='valid')
ax[1].set_xlabel('epoch')
ax[1].set_ylabel('accuracy')
ax[1].legend()
plt.show()
#Calcul du taux de réponse correcte
def calculate_accuracy(model, dataset, device):
#Créer un chargeur de données
loader = DataLoader(dataset, batch_size=len(dataset), shuffle=False)
model.eval()
total = 0
correct = 0
with torch.no_grad():
for data in loader:
#Spécification de l'appareil
ids = data['ids'].to(device)
mask = data['mask'].to(device)
labels = data['labels'].to(device)
#Propagation vers l'avant+Obtenez la valeur prévue+Compter le nombre de bonnes réponses
outputs = model.forward(ids, mask)
pred = torch.argmax(outputs, dim=-1).cpu().numpy()
labels = torch.argmax(labels, dim=-1).cpu().numpy()
total += len(labels)
correct += (pred == labels).sum().item()
return correct / total
print(f'Taux de réponse correct (données d'apprentissage):{calculate_accuracy(model, dataset_train, device):.3f}')
print(f'Taux de réponse correct (données de vérification):{calculate_accuracy(model, dataset_valid, device):.3f}')
print(f'Taux de réponse correct (données d'évaluation):{calculate_accuracy(model, dataset_test, device):.3f}')
production
Taux de réponse correct (données d'apprentissage): 0.993
Taux de réponse correct (données de vérification): 0.929
Taux de réponse correct (données d'évaluation): 0.948
Le taux de réponse correcte était d'environ 95% dans les données d'évaluation.
Normalement, je pense que dans de nombreux cas, des paramètres tels que la fixation ou non des poids pour chaque couche de BERT et le taux d'apprentissage sont ajustés tout en vérifiant l'exactitude des données de vérification. Cette fois, les paramètres ont été fixés, mais la précision était relativement élevée et le résultat a montré la force du pré-apprentissage.
référence
transformers BERT (officiel) BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding, Devlin, J. et al. (2018) (Article original) [Language processing 100 knock 2020] Résumé des exemples de réponses par Python