By James Briggs, Scientifique des données

BERT, mais en Italie — image de l'auteur

Beaucoup de mes articles se sont concentrés sur BERT - le modèle qui a dominé le monde du traitement du langage naturel (TAL) et a marqué une nouvelle ère pour les modèles de langage.

Pour ceux d'entre vous qui n'ont peut-être pas utilisé de modèles de transformateurs (par exemple, ce qu'est BERT), le processus ressemble un peu à ceci :

• pip install transformers
• Initialiser un modèle de transformateurs pré-entraînés — from_pretrained.
• Testez-le sur certaines données.
• Peut-être affiner le modèle (le former un peu plus).

Maintenant, c'est une excellente approche, mais si nous ne faisons que cela, nous manquons de compréhension pour créer nos propres modèles de transformateurs.

Et, si nous ne pouvons pas créer nos propres modèles de transformateurs - nous devons compter sur l'existence d'un modèle pré-formé qui correspond à notre problème, ce n'est pas toujours le cas :

Quelques commentaires sur les modèles BERT non anglais

Ainsi, dans cet article, nous explorerons les étapes à suivre pour créer notre propre modèle de transformateur - en particulier une version plus développée de BERT, appelée RoBERTa.

Un aperçu

 
 
Il y a quelques étapes dans le processus, donc avant de plonger, résumons d'abord ce que nous devons faire. Au total, il y a quatre parties clés :

• Obtenir les données
• Construire un tokenizer
• Création d'un pipeline d'entrée
• Former le modèle

Une fois que nous aurons parcouru chacune de ces sections, nous prendrons le tokenizer et le modèle que nous avons construits - et les enregistrerons tous les deux afin que nous puissions ensuite les utiliser de la même manière que nous le ferions habituellement avec from_pretrained.

Obtenir les données

 
 
Comme pour tout projet d'apprentissage automatique, nous avons besoin de données. En termes de données pour la formation d'un modèle de transformateur, nous n'avons vraiment que l'embarras du choix - nous pouvons utiliser presque toutes les données textuelles.

Et, s'il y a une chose que nous avons en abondance sur Internet, ce sont des données textuelles non structurées.

L'un des plus grands ensembles de données dans le domaine du texte extrait d'Internet est l'ensemble de données OSCAR.

L'ensemble de données OSCAR comprend un grand nombre de langues différentes - et l'un des cas d'utilisation les plus clairs pour la formation à partir de zéro est que nous puissions appliquer BERT à certaines langues moins couramment utilisées, telles que le télougou ou le navajo.

Malheureusement, la seule langue que je peux parler avec n'importe quel degré de compétence est l'anglais - mais ma petite amie est italienne, et donc elle - Laura, évaluera les résultats de notre modèle BERT italophone - FiliBERTo.

Ainsi, pour télécharger le segment italien de l'ensemble de données OSCAR, nous utiliserons HuggingFace's datasets bibliothèque - que nous pouvons installer avec pip install datasets. Puis on télécharge OSCAR_IT avec :

Jetons un coup d'oeil au dataset objet.

Super, stockons maintenant nos données dans un format que nous pouvons utiliser lors de la construction de notre tokenizer. Nous devons créer un ensemble de fichiers en clair contenant uniquement les text caractéristique de notre ensemble de données, et nous diviserons chaque échantillon en utilisant une nouvelle ligne n.

Plus dans notre data/text/oscar_it répertoire nous trouverons:

Le répertoire contenant nos fichiers OSCAR en clair

Construire un Tokenizer

 
 
La prochaine étape est le tokenizer ! Lors de l'utilisation de transformateurs, nous chargeons généralement un tokenizer, à côté de son modèle de transformateur respectif - le tokenizer est un élément clé du processus.

Lors de la construction de notre tokenizer, nous lui fournirons toutes nos données OSCAR, spécifierons la taille de notre vocabulaire (nombre de tokens dans le tokenizer) et tous les tokens spéciaux.

Maintenant, les jetons spéciaux RoBERTa ressemblent à ceci :

Nous nous assurons donc de les inclure dans le special_tokens paramètre de notre tokenizer train appel de méthode.

Notre tokenizer est maintenant prêt, et nous pouvons l'enregistrer pour une utilisation ultérieure :

Nous avons maintenant deux fichiers qui définissent notre nouveau FiliBERÀ tokenizer :

• fusions.txt - effectue le mappage initial du texte sur les jetons
• vocabulaire.json - mappe les jetons aux ID de jeton

Et avec ceux-ci, nous pouvons passer à l'initialisation de notre tokenizer afin de pouvoir l'utiliser comme nous utiliserions n'importe quel autre from_pretrained tokeniseur.

Initialisation du Tokenizer

 
 
Nous initialisons d'abord le tokenizer en utilisant les deux fichiers que nous avons construits auparavant - en utilisant un simple from_pretrained:

Maintenant que notre tokenizer est prêt, nous pouvons essayer d'encoder du texte avec. Lors de l'encodage, nous utilisons les deux mêmes méthodes que nous utiliserions généralement, encode ainsi que encode_batch.

Depuis l'objet encodings tokens nous allons extraire le input_ids ainsi que attention_mask tenseurs à utiliser avec FiliBERTo.

Création du pipeline d'entrée

 
 
Le pipeline d'entrée de notre processus de formation est la partie la plus complexe de l'ensemble du processus. Cela consiste à prendre nos données brutes d'entraînement OSCAR, à les transformer et à les charger dans un DataLoader prêt pour la formation.

Préparation des données

 
 
Nous allons commencer avec un seul échantillon et suivre la logique de préparation.

Tout d'abord, nous devons ouvrir notre fichier - les mêmes fichiers que nous avons enregistrés sous .SMS fichiers plus tôt. Nous divisons chacun en fonction des caractères de nouvelle ligne n car cela indique les échantillons individuels.

Ensuite, nous encodons nos données à l'aide de la tokenizer - en veillant à inclure des paramètres clés tels que max_length, paddinget une truncation.

Et maintenant, nous pouvons passer à la création de nos tenseurs - nous allons entraîner notre modèle via la modélisation en langage masqué (MLM). Donc, nous avons besoin de trois tenseurs :

• ID_entrée - notre token_ids avec ~15 % de jetons masqués à l'aide du jeton de masque <mask>.
• masque_attention — un tenseur de 1s et 0s, marquant la position des "vrais" jetons / jetons de remplissage - utilisés dans les calculs d'attention.
• qui - notre token_ids comprenant aucune masquage.

Si vous n'êtes pas familier avec le MLM, je l'ai expliqué ici.

Notre attention_mask ainsi que labels les tenseurs sont simplement extraits de notre batchL’ input_ids les tenseurs nécessitent plus d'attention cependant, pour ce tenseur, nous masquons environ 15 % des jetons - en leur attribuant l'ID de jeton 3.

Dans la sortie finale, nous pouvons voir une partie d'un fichier codé input_ids tenseur. Le tout premier identifiant de jeton est 1 - L' [CLS] jeton. En pointillés autour du tenseur, nous avons plusieurs 3 ID de jeton - ce sont nos nouveaux [MASK] jetons.

Construire le chargeur de données

 
 
Ensuite, nous définissons notre Dataset class - que nous utilisons pour initialiser nos trois tenseurs codés en tant que PyTorch torch.utils.data.Dataset objets.

Enfin, notre dataset est chargé dans un PyTorch DataLoader objet - que nous utilisons pour charger nos données dans notre modèle pendant la formation.

Entraîner le modèle

 
 
Nous avons besoin de deux choses pour la formation, notre DataLoader et un modèle. Le DataLoader nous avons — mais pas de modèle.

Initialisation du modèle

 
 
Pour la formation, nous avons besoin d'un raw (non pré-formé) BERTLMHeadModel. Pour créer cela, nous devons d'abord créer un objet de configuration RoBERTa pour décrire les paramètres avec lesquels nous aimerions initialiser FiliBERTo.

Ensuite, nous importons et initialisons notre modèle RoBERTa avec une tête de modélisation de langage (LM).

Préparation à la formation

 
 
Avant de passer à notre boucle d'entraînement, nous devons mettre en place quelques éléments. Tout d'abord, nous configurons l'utilisation du GPU/CPU. Ensuite, nous activons le mode d'apprentissage de notre modèle — et enfin, initialisons notre optimiseur.

Formation

 
 
Enfin — le temps de la formation ! Nous nous entraînons comme nous le ferions habituellement lors d'une formation via PyTorch.

Si nous nous dirigeons vers Tensorboard, nous trouverons notre perte au fil du temps – cela semble prometteur.

Perte / temps - plusieurs sessions de formation ont été regroupées dans ce tableau

Le vrai test

 
 
Il est maintenant temps pour le vrai test. Nous avons mis en place un pipeline MLM - et demandons à Laura d'évaluer les résultats. Vous pouvez regarder la critique vidéo à 22:44 ici:

On initialise d'abord un pipeline objet, en utilisant le 'fill-mask' argument. Ensuite, commencez à tester notre modèle comme suit :

« ciao comment Virginie?" est la bonne réponse ! C'est aussi avancé que mon italien devient - alors, laissons le relais à Laura.

Nous commençons avec "buongiorno, viens va?" - ou "bonne journée Comment allez-vous?":

La première réponse, "buongiorno, chi va?" signifie "Bonjour, qui est là?" - par exemple absurde. Mais, notre deuxième réponse est correcte !

Ensuite, une phrase un peu plus dure, « ciao, colombe ci incontriamo oggi pomeriggio ? - ou "salut, où allons-nous nous rencontrer cet après-midi ?":

Et nous retournons des résultats plus positifs :

✅ "hi, where do we see each other this afternoon?"
✅ "hi, where do we meet this afternoon?"
❌ "hi, where here we are this afternoon?"
✅ "hi, where are we meeting this afternoon?"
✅ "hi, where do we meet this afternoon?"

Enfin, une phrase de plus, plus dure, "cosa sarebbe successo se avessimo scelto un altro giorno?" — ou « que se serait-il passé si nous avions choisi un autre jour ? » :

Nous retournons ici aussi quelques bonnes bonnes réponses :

✅ "what would have happened if we had chosen another day?"
✅ "what would have happened if I had chosen another day?"
✅ "what would have happened if they had chosen another day?"
✅ "what would have happened if you had chosen another day?"
❌ "what would have happened if another day was chosen?"

Dans l'ensemble, il semble que notre modèle ait réussi les tests de Laura - et nous avons maintenant un modèle de langue italienne compétent appelé FiliBERTo !

C'est tout pour cette procédure pas à pas de formation d'un modèle BERT à partir de zéro !

Nous avons couvert beaucoup de terrain, depuis l'obtention et le formatage de nos données jusqu'à l'utilisation de la modélisation du langage pour former notre modèle BERT brut.

J'espère que cet article vous a plu ! Si vous avez des questions, faites-le moi savoir via Twitter ou dans les commentaires ci-dessous. Si vous souhaitez plus de contenu comme celui-ci, je poste sur  YouTube trop.

Merci pour la lecture!

70 % de réduction ! Traitement automatique du langage naturel : NLP avec transformateurs en Python

Les modèles de transformateurs sont la norme de facto dans la PNL moderne. Ils se sont révélés être les plus expressifs…
 

*Toutes les images sont de l'auteur sauf indication contraire

 
Bio: James Briggs est un data scientist spécialisé dans le traitement du langage naturel et travaillant dans le secteur financier, basé à Londres, au Royaume-Uni. Il est également un mentor indépendant, un écrivain et un créateur de contenu. Vous pouvez joindre l'auteur par e-mail (jamescalam94@gmail.com).

ORIGINALE. Republié avec permission.

Connexe:

• Comment appliquer des transformateurs à n'importe quelle longueur de texte
• Comprendre BERT avec Hugging Face
• Modélisation de sujets avec BERT