Page d'accueil>Lié à la programmation>Code Source AI
Télécharger

DeBERTa : BERT amélioré par décodage avec une attention démêlée

Ce référentiel est l'implémentation officielle de DeBERTa : Décodage - BERT amélioré avec attention disentangled et DeBERTa V3 : Amélioration DeBERTa à l'aide d'une pré-formation de style ELECTRA avec partage d'intégration dégradé-disentangled

Nouvelles

18/03/2023

  • Le papier DeBERTa V3 est accepté par l'ICLR 2023.
  • Le code pour la pré-formation et la formation continue DeBERTa V3 est ajouté. Veuillez consulter le modèle linguistique pour plus de détails.

12/8/2021

  • DeBERTa -V3-XSmall est ajouté. Avec seulement 22 millions de paramètres de base, soit seulement 1/4 de RoBERTa-Base et XLNet-Base, DeBERTa -V3-XSmall surpasse considérablement les dernières tâches MNLI et SQuAD v2.0 (soit 1,2 % sur MNLI-m, 1,5 % de score EM). sur SQuAD v2.0). Cela démontre encore l’efficacité des modèles DeBERTa V3.

16/11/2021

  • Les modèles de notre nouveau travail DeBERTa V3 : Amélioration DeBERTa à l'aide de la pré-formation de style ELECTRA avec partage d'intégration dégradé-disentangled sont désormais disponibles publiquement sur le hub de modèles huggingface. Les nouveaux modèles sont basés sur les modèles DeBERTa -V2 en remplaçant MLM par un objectif de style ELECTRA plus un partage d'intégration démêlé par gradient qui améliore encore l'efficacité du modèle.
  • Des scripts pour le réglage fin du modèle DeBERTa V3 sont ajoutés
  • Le code du chef de tâche RTD est ajouté
  • Un document pour la pré-formation du modèle de langage est ajouté

31/03/2021

  • La tâche de modèle de langage masqué est ajoutée
  • Les tâches SuperGLUE sont ajoutées
  • Le code SiFT est ajouté

03/02/2021

Le code DeBERTa v2 et le modèle 900M, 1.5B sont ici maintenant. Cela inclut le modèle 1,5B utilisé pour notre soumission de modèle unique SuperGLUE et atteignant 89,9, contre 89,8 de référence humaine. Vous pouvez trouver plus de détails sur cette soumission sur notre blog

Quoi de neuf dans la v2

  • Vocabulaire Dans la v2, nous utilisons un nouveau vocabulaire de taille 128K construit à partir des données d'entraînement. Au lieu du tokenizer GPT2, nous utilisons le tokenizer sentencepiece.
  • nGiE (nGram Induced Input Encoding) Dans la v2, nous utilisons une couche de convolution supplémentaire en plus de la première couche de transformateur pour mieux apprendre la dépendance locale des jetons d'entrée. Nous ajouterons d'autres études d'ablation sur cette fonctionnalité.
  • Partager la matrice de projection de position avec la matrice de projection de contenu dans la couche d'attention . Sur la base de notre expérience précédente, nous avons constaté que cela pouvait enregistrer les paramètres sans affecter les performances.
  • Appliquer le bucket pour encoder les positions relatives Dans la v2, nous utilisons le bucket de journaux pour encoder les positions relatives similaires à T5.
  • Modèle 900M et modèle 1,5B Dans la v2, nous adaptons la taille de notre modèle à 900M et 1,5B, ce qui améliore considérablement les performances des tâches en aval.

29/12/2020

Avec le modèle DeBERTa 1.5B, nous surpassons le modèle T5 11B et les performances humaines dans le classement SuperGLUE. Le code et le modèle seront bientôt publiés. Veuillez consulter notre article pour plus de détails.

13/06/2020

Nous avons publié les modèles pré-entraînés, le code source et les scripts de réglage fin pour reproduire certains des résultats expérimentaux dans l'article. Vous pouvez suivre des scripts similaires pour appliquer DeBERTa à vos propres expériences ou applications. Les scripts de pré-formation seront publiés à l'étape suivante.

Introduction à DeBERTa

DeBERTa (Decoding-enhanced BERT with démêlé attention) améliore les modèles BERT et RoBERTa à l'aide de deux nouvelles techniques. Le premier est le mécanisme d’attention démêlée, où chaque mot est représenté à l’aide de deux vecteurs qui codent respectivement son contenu et sa position, et les poids d’attention entre les mots sont calculés à l’aide de matrices démêlées sur leur contenu et leurs positions relatives. Deuxièmement, un décodeur de masque amélioré est utilisé pour remplacer la couche softmax de sortie afin de prédire les jetons masqués pour le pré-entraînement du modèle. Nous montrons que ces deux techniques améliorent considérablement l'efficacité de la pré-formation du modèle et la performance des tâches en aval.

Modèles pré-entraînés

Nos modèles pré-entraînés sont regroupés dans des fichiers compressés. Vous pouvez les télécharger à partir de nos versions ou télécharger un modèle individuel via les liens ci-dessous :

Modèle Vocabulaire (K) Paramètres de la colonne vertébrale (M) Taille cachée Calques Note
V2-XXGrand 1 128 1320 1536 48 128 000 nouveaux vocabulaires SPM
V2-XL 128 710 1536 24 128 000 nouveaux vocabulaires SPM
XLarge 50 700 1024 48 Même vocabulaire que RoBERTa
Grand 50 350 1024 24 Même vocabulaire que RoBERTa
Base 50 100 768 12 Même vocabulaire que RoBERTa
V2-XXLarge-MNLI 128 1320 1536 48 Tournage fin avec MNLI
V2-XLarge-MNLI 128 710 1536 24 Tournage fin avec MNLI
XLarge-MNLI 50 700 1024 48 Tournage fin avec MNLI
Grand-MNLI 50 350 1024 24 Tournage fin avec MNLI
Base-MNLI 50 86 768 12 Tournage fin avec MNLI
DeBERTa -V3-Grand 2 128 304 1024 24 128 000 nouveaux vocabulaires SPM
DeBERTa -V3-Base 2 128 86 768 12 128 000 nouveaux vocabulaires SPM
DeBERTa -V3-Petit 2 128 44 768 6 128 000 nouveaux vocabulaires SPM
DeBERTa -V3-XSmall 2 128 22 384 12 128 000 nouveaux vocabulaires SPM
m DeBERTa -V3-Base 2 250 86 768 12 250 000 nouveaux vocabulaires SPM, modèle multilingue avec 102 langues

Note

  • 1 Il s'agit du modèle (89,9) qui a dépassé pour la première fois le T5 11B (89,3) et les performances humaines (89,8) sur SuperGLUE . 128 000 nouveaux vocabulaires SPM.
  • 2 Ces modèles DeBERTa V3 sont des modèles DeBERTa pré-entraînés avec un objectif de style ELECTRA plus un partage d'intégration démêlé par gradient qui améliore considérablement l'efficacité du modèle.

Essayez le modèle

Lire notre documentation

Exigences

  • Système Linux, par exemple Ubuntu 18.04LTS
  • CUDA 10.0
  • pytorche 1.3.0
  • python 3.6
  • shell bash 4.0
  • boucle
  • docker (facultatif)
  • nvidia-docker2 (facultatif)

Il existe plusieurs façons d'essayer notre code,

Utiliser le menu fixe

Docker est le moyen recommandé pour exécuter le code car nous avons déjà intégré toutes les dépendances dans notre docker bagai/ DeBERTa et vous pouvez suivre le site officiel de docker pour installer docker sur votre machine.

Pour exécuter avec Docker, assurez-vous que votre système remplit les conditions requises dans la liste ci-dessus. Voici les étapes pour essayer les expériences GLUE : extrayez le code, exécutez ./run_docker.sh , puis vous pourrez exécuter les commandes bash sous / DeBERTa /experiments/glue/

Utiliser pip

Extrayez le code et exécutez pip3 install -r requirements.txt dans le répertoire racine du code, puis entrez dans le dossier experiments/glue/ du code et essayez les commandes bash sous ce dossier pour les expériences de colle.

Installer en tant que package pip

pip install DeBERTa

Utiliser DeBERTa dans le code existant

DeBERTa to your existing code, you need to make two changes to your code, # 1. change your model to consume DeBERTa as the encoder from DeBERTa import DeBERTa import torch class MyModel(torch.nn.Module): def __init__(self): super().__init__() # Your existing model code self. DeBERTa = DeBERTa . DeBERTa (pre_trained='base') # Or 'large' 'base-mnli' 'large-mnli' 'xlarge' 'xlarge-mnli' 'xlarge-v2' 'xxlarge-v2' # Your existing model code # do inilization as before # self. DeBERTa .apply_state() # Apply the pre-trained model of DeBERTa at the end of the constructor # def forward(self, input_ids): # The inputs to DeBERTa forward are # `input_ids`: a torch.LongTensor of shape [batch_size, sequence_length] with the word token indices in the vocabulary # `token_type_ids`: an optional torch.LongTensor of shape [batch_size, sequence_length] with the token types indices selected in [0, 1]. # Type 0 corresponds to a `sentence A` and type 1 corresponds to a `sentence B` token (see BERT paper for more details). # `attention_mask`: an optional parameter for input mask or attention mask. # - If it's an input mask, then it will be torch.LongTensor of shape [batch_size, sequence_length] with indices selected in [0, 1]. # It's a mask to be used if the input sequence length is smaller than the max input sequence length in the current batch. # It's the mask that we typically use for attention when a batch has varying length sentences. # - If it's an attention mask then if will be torch.LongTensor of shape [batch_size, sequence_length, sequence_length]. # In this case, it's a mask indicating which tokens in the sequence should be attended by other tokens in the sequence. # `output_all_encoded_layers`: whether to output results of all encoder layers, default, True encoding = DeBERTa .bert(input_ids)[-1] # 2. Change your tokenizer with the tokenizer built-in DeBERTa from DeBERTa import DeBERTa vocab_path, vocab_type = DeBERTa .load_vocab(pretrained_id='base') tokenizer = DeBERTa .tokenizers[vocab_type](vocab_path) # We apply the same schema of special tokens as BERT, e.g. [CLS], [SEP], [MASK] max_seq_len = 512 tokens = tokenizer.tokenize('Examples input text of DeBERTa ') # Truncate long sequence tokens = tokens[:max_seq_len -2] # Add special tokens to the `tokens` tokens = ['[CLS]'] + tokens + ['[SEP]'] input_ids = tokenizer.convert_tokens_to_ids(tokens) input_mask = [1]*len(input_ids) # padding paddings = max_seq_len-len(input_ids) input_ids = input_ids + [0]*paddings input_mask = input_mask + [0]*paddings features = { 'input_ids': torch.tensor(input_ids, dtype=torch.int), 'input_mask': torch.tensor(input_mask, dtype=torch.int) } ">
 # To apply DeBERTa to your existing code, you need to make two changes to your code,
# 1. change your model to consume DeBERTa as the encoder
from DeBERTa import DeBERTa
import torch
class MyModel ( torch . nn . Module ):
  def __init__ ( self ):
    super (). __init__ ()
    # Your existing model code
    self . DeBERTa = DeBERTa . DeBERTa ( pre_trained = 'base' ) # Or 'large' 'base-mnli' 'large-mnli' 'xlarge' 'xlarge-mnli' 'xlarge-v2' 'xxlarge-v2'
    # Your existing model code
    # do inilization as before
    # 
    self . DeBERTa . apply_state () # Apply the pre-trained model of DeBERTa at the end of the constructor
    #
  def forward ( self , input_ids ):
    # The inputs to DeBERTa forward are
    # `input_ids`: a torch.LongTensor of shape [batch_size, sequence_length] with the word token indices in the vocabulary
    # `token_type_ids`: an optional torch.LongTensor of shape [batch_size, sequence_length] with the token types indices selected in [0, 1]. 
    #    Type 0 corresponds to a `sentence A` and type 1 corresponds to a `sentence B` token (see BERT paper for more details).
    # `attention_mask`: an optional parameter for input mask or attention mask. 
    #   - If it's an input mask, then it will be torch.LongTensor of shape [batch_size, sequence_length] with indices selected in [0, 1]. 
    #      It's a mask to be used if the input sequence length is smaller than the max input sequence length in the current batch. 
    #      It's the mask that we typically use for attention when a batch has varying length sentences.
    #   - If it's an attention mask then if will be torch.LongTensor of shape [batch_size, sequence_length, sequence_length]. 
    #      In this case, it's a mask indicating which tokens in the sequence should be attended by other tokens in the sequence. 
    # `output_all_encoded_layers`: whether to output results of all encoder layers, default, True
    encoding = DeBERTa . bert ( input_ids )[ - 1 ]

# 2. Change your tokenizer with the tokenizer built-in DeBERTa
from DeBERTa import DeBERTa
vocab_path , vocab_type = DeBERTa . load_vocab ( pretrained_id = 'base' )
tokenizer = DeBERTa . tokenizers [ vocab_type ]( vocab_path )
# We apply the same schema of special tokens as BERT, e.g. [CLS], [SEP], [MASK]
max_seq_len = 512
tokens = tokenizer . tokenize ( 'Examples input text of DeBERTa ' )
# Truncate long sequence
tokens = tokens [: max_seq_len - 2 ]
# Add special tokens to the `tokens`
tokens = [ '[CLS]' ] + tokens + [ '[SEP]' ]
input_ids = tokenizer . convert_tokens_to_ids ( tokens )
input_mask = [ 1 ] * len ( input_ids )
# padding
paddings = max_seq_len - len ( input_ids )
input_ids = input_ids + [ 0 ] * paddings
input_mask = input_mask + [ 0 ] * paddings
features = {
'input_ids' : torch . tensor ( input_ids , dtype = torch . int ),
'input_mask' : torch . tensor ( input_mask , dtype = torch . int )
}

Exécuter des expériences DeBERTa à partir de la ligne de commande

Pour les tâches de colle,

  1. Obtenez les données
DeBERTa/ cd experiments/glue ./download_data.sh $cache_dir/glue_tasks">
cache_dir=/tmp/ DeBERTa /
cd experiments/glue
./download_data.sh  $cache_dir /glue_tasks
  1. Exécuter la tâche
DeBERTa/exps/$task export OMP_NUM_THREADS=1 python3 -m DeBERTa .apps.run --task_name $task --do_train --data_dir $cache_dir/glue_tasks/$task --eval_batch_size 128 --predict_batch_size 128 --output_dir $OUTPUT --scale_steps 250 --loss_scale 16384 --accumulative_update 1 --num_train_epochs 6 --warmup 100 --learning_rate 2e-5 --train_batch_size 32 --max_seq_len 128">
task=STS-B 
OUTPUT=/tmp/ DeBERTa /exps/ $task
export OMP_NUM_THREADS=1
python3 -m DeBERTa .apps.run --task_name $task --do_train  
  --data_dir $cache_dir /glue_tasks/ $task 
  --eval_batch_size 128 
  --predict_batch_size 128 
  --output_dir $OUTPUT 
  --scale_steps 250 
  --loss_scale 16384 
  --accumulative_update 1   
  --num_train_epochs 6 
  --warmup 100 
  --learning_rate 2e-5 
  --train_batch_size 32 
  --max_seq_len 128

Remarques

    1. Par défaut, nous mettrons en cache le modèle pré-entraîné et le tokenizer dans $HOME/.~ DeBERTa , vous devrez peut-être le nettoyer si le téléchargement échoue de manière inattendue.
    1. Vous pouvez également essayer nos modèles avec Transformateurs HF. Mais lorsque vous essayez le modèle XXLarge, vous devez spécifier l'argument --sharded_ddp. Veuillez consulter notre carte modèle XXLarge pour plus de détails.

Expériences

Nos expériences de réglage fin sont réalisées sur un demi-nœud DGX-2 avec 8x32 cartes GPU V100, les résultats peuvent varier en raison des différents modèles de GPU, pilotes, versions du SDK CUDA, utilisant FP16 ou FP32 et des graines aléatoires. Nous rapportons ici nos chiffres basés sur plusieurs analyses avec différentes graines aléatoires. Voici les résultats du grand modèle :

Tâche Commande Résultats Temps d'exécution (GPU 8x32G V100)
MNLI xxlarge v2 experiments/glue/mnli.sh xxlarge-v2 91,7/91,9 +/-0,1 4h
MNLI xlarge v2 experiments/glue/mnli.sh xlarge-v2 91,7/91,6 +/-0,1 2h30
MNLI xlarge experiments/glue/mnli.sh xlarge 91,5/91,2 +/-0,1 2h30
MNLI grand experiments/glue/mnli.sh large 91,3/91,1 +/-0,1 2h30
QQP grand experiments/glue/qqp.sh large 92,3 +/-0,1 6h
QNLI grand experiments/glue/qnli.sh large 95,3 +/-0,2 2h
MRPC grand experiments/glue/mrpc.sh large 91,9 +/-0,5 0,5h
RTE grand experiments/glue/rte.sh large 86,6 +/-1,0 0,5h
SST-2 grand experiments/glue/sst2.sh large 96,7 +/-0,3 1h
STS-b grand experiments/glue/Stsb.sh large 92,5 +/-0,3 0,5h
CoLA grand experiments/glue/cola.sh 70,5 +/-1,0 0,5h

Et voici les résultats du modèle de base

Tâche Commande Résultats Temps d'exécution (GPU 8x32G V100)
Base MNLI experiments/glue/mnli.sh base 88,8/88,5 +/-0,2 1h30

Affinement des tâches NLU

Nous présentons les résultats de développement sur SQuAD 1.1/2.0 et plusieurs tâches de benchmark GLUE.

Modèle ESCOUADE 1.1 ESCOUADE 2.0 MNLI-m/mm SST-2 QNLI Cola RTE MRPC QQP STS-B
F1/ME F1/ME Acc Acc Acc Centre multicompte Acc Acc/F1 Acc/F1 P/S
BERT-Grand 90,9/84,1 81,8/79,0 86,6/- 93.2 92,3 60,6 70,4 88,0/- 91,3/- 90,0/-
RoBERTa-Large 94,6/88,9 89,4/86,5 90,2/- 96,4 93,9 68,0 86,6 90,9/- 92,2/- 92,4/-
XLNet-Grand 95,1/89,7 90,6/87,9 90,8/- 97,0 94,9 69,0 85,9 90,8/- 92,3/- 92,5/-
DeBERTa -Grand 1 95,5/90,1 90,7/88,0 91,3/91,1 96,5 95,3 69,5 91,0 92,6/94,6 92,3/- 92,8/92,5
DeBERTa -XLarge 1 -/- -/- 91,5/91,2 97,0 - - 93.1 92,1/94,3 - 92,9/92,7
DeBERTa -V2-XLarge 1 95,8/90,8 91,4/88,9 91,7/91,6 97,5 95,8 71.1 93,9 92,0/94,2 92,3/89,8 92,9/92,9
DeBERTa -V2-XXLarge 1,2 96,1/91,4 92,2/89,7 91,7/91,9 97,2 96,0 72,0 93,5 93,1/94,9 92,7/90,3 93,2/93,1
DeBERTa -V3-Grand -/- 91,5/89,0 91,8/91,9 96,9 96,0 75.3 92,7 92,2/- 93,0/- 93,0/-
DeBERTa -V3-Base -/- 88,4/85,4 90,6/90,7 - - - - - - -
DeBERTa -V3-Petit -/- 82,9/80,4 88,3/87,7 - - - - - - -
DeBERTa -V3-XSmall -/- 84,8/82,0 88,1/88,3 - - - - - - -

Mise au point sur XNLI

Nous présentons les résultats du développement sur XNLI avec un paramètre de transfert multilingue zéro-shot, c'est-à-dire une formation avec des données en anglais uniquement, un test sur d'autres langues.

Modèle moyenne fr fr es de el bg ru tr ar vi ème zh Salut sw ton
Base XLM-R 76.2 85,8 79,7 80,7 78,7 77,5 79,6 78.1 74.2 73,8 76,5 74,6 76,7 72,4 66,5 68,3
m DeBERTa -V3-Base 79,8 +/-0,2 88,2 82,6 84,4 82,7 82,3 82,4 80,8 79,5 78,5 78.1 76,4 79,5 75,9 73,9 72,4

Remarques.

  • 1 Suite à RoBERTa, pour RTE, MRPC, STS-B, nous affinons les tâches basées sur DeBERTa -Large-MNLI, DeBERTa -XLarge-MNLI, DeBERTa -V2-XLarge-MNLI, DeBERTa -V2-XXLarge-MNLI. Les résultats de SST-2/QQP/QNLI/SQuADv2 seront également légèrement améliorés en partant de modèles affinés MNLI, cependant, nous ne rapportons que les chiffres affinés à partir de modèles de base pré-entraînés pour ces 4 tâches.

Pré-formation avec objectifs MLM et RTD

Pour pré-entraîner DeBERTa avec les objectifs MLM et RTD, veuillez consulter experiments/language_models

Contacts

Pengcheng He ([email protected]), Xiaodong Liu ([email protected]), Jianfeng Gao ([email protected]), Weizhu Chen ([email protected])

Citation

DeBERTav3, title={ DeBERTa V3: Improving DeBERTa using ELECTRA-Style Pre-Training with Gradient-Disentangled Embedding Sharing}, author={Pengcheng He and Jianfeng Gao and Weizhu Chen}, year={2021}, eprint={2111.09543}, archivePrefix={arXiv}, primaryClass={cs.CL} }">
@misc{he2021 DeBERTa v3,
      title={ DeBERTa V3: Improving DeBERTa using ELECTRA-Style Pre-Training with Gradient-Disentangled Embedding Sharing}, 
      author={Pengcheng He and Jianfeng Gao and Weizhu Chen},
      year={2021},
      eprint={2111.09543},
      archivePrefix={arXiv},
      primaryClass={cs.CL}
}
DeBERTa, title={ DeBERTa : DECODING-ENHANCED BERT WITH DISENTANGLED ATTENTION}, author={Pengcheng He and Xiaodong Liu and Jianfeng Gao and Weizhu Chen}, booktitle={International Conference on Learning Representations}, year={2021}, url={https://openreview.net/forum?id=XPZIaotutsD} }">
@inproceedings{
he2021 DeBERTa ,
title={ DeBERTa : DECODING-ENHANCED BERT WITH DISENTANGLED ATTENTION},
author={Pengcheng He and Xiaodong Liu and Jianfeng Gao and Weizhu Chen},
booktitle={International Conference on Learning Representations},
year={2021},
url={https://openreview.net/forum?id=XPZIaotutsD}
}
Développer
Informations supplémentaires
Applications connexes
Recommandé pour vous
Actualités connexes Tout