Página Inicial>Relacionado com a programação>Código-Fonte de IA
Baixar

DeBERTa : BERT aprimorado por decodificação com atenção desembaraçada

Este repositório é a implementação oficial de DeBERTa : Decoding - enhanced BERT with Disentangled A ttention e DeBERTa V3: Improving DeBERTa usando ELECTRA-Style Pre-Training com Gradient-Disentangled Embedding Sharing

Notícias

18/03/2023

  • O artigo DeBERTa V3 é aceito pelo ICLR 2023.
  • O código para pré-treinamento e treinamento contínuo DeBERTa V3 é adicionado. Por favor, verifique o modelo de idioma para obter detalhes.

08/12/2021

  • DeBERTa -V3-XSmall é adicionado. Com apenas 22M de parâmetros de backbone, que são apenas 1/4 do RoBERTa-Base e XLNet-Base, DeBERTa -V3-XSmall supera significativamente o desempenho posterior nas tarefas MNLI e SQuAD v2.0 (ou seja, 1,2% em MNLI-m, 1,5% de pontuação EM no SQuAD v2.0). Isto demonstra ainda mais a eficiência dos modelos DeBERTa V3.

16/11/2021

  • Os modelos de nosso novo trabalho DeBERTa V3: Melhorando DeBERTa usando o pré-treinamento estilo ELECTRA com compartilhamento de incorporação desemaranhado de gradiente estão disponíveis publicamente no hub de modelo huggingface agora. Os novos modelos são baseados nos modelos DeBERTa -V2, substituindo o MLM pela objetiva estilo ELECTRA, além do compartilhamento de incorporação desembaraçado por gradiente, o que melhora ainda mais a eficiência do modelo.
  • Scripts para ajuste fino do modelo DeBERTa V3 são adicionados
  • O código do cabeçalho da tarefa RTD é adicionado
  • Documento para pré-treinamento do modelo de linguagem é adicionado

31/03/2021

  • A tarefa de modelo de linguagem mascarada foi adicionada
  • Tarefas SuperGLUE são adicionadas
  • O código SiFT é adicionado

03/02/2021

O código DeBERTa v2 e o modelo 900M, 1.5B já estão aqui. Isso inclui o modelo 1,5B usado para nosso envio de modelo único SuperGLUE e alcançou 89,9, versus 89,8 da linha de base humana. Você pode encontrar mais detalhes sobre este envio em nosso blog

O que há de novo na v2

  • Vocabulário Na v2 usamos um novo vocabulário de tamanho 128K construído a partir dos dados de treinamento. Em vez do tokenizer GPT2, usamos o tokenizer de frase.
  • nGiE (nGram Induced Input Encoding) Na v2, usamos uma camada de convolução adicional além da primeira camada do transformador para aprender melhor a dependência local dos tokens de entrada. Adicionaremos mais estudos de ablação sobre esse recurso.
  • Compartilhando a matriz de projeção de posição com a matriz de projeção de conteúdo na camada de atenção Com base em nosso experimento anterior, descobrimos que isso pode salvar parâmetros sem afetar o desempenho.
  • Aplicar bucket para codificar posições relativas Na v2, usamos bucket de log para codificar posições relativas semelhantes a T5.
  • Modelo 900M e modelo 1,5B Na v2, dimensionamos o tamanho do nosso modelo para 900M e 1,5B, o que melhora significativamente o desempenho das tarefas posteriores.

29/12/2020

Com o modelo DeBERTa 1.5B, superamos o modelo T5 11B e o desempenho humano na tabela de classificação SuperGLUE. Código e modelo serão divulgados em breve. Por favor, verifique nosso artigo para mais detalhes.

13/06/2020

Lançamos os modelos pré-treinados, o código-fonte e os scripts de ajuste fino para reproduzir alguns dos resultados experimentais no artigo. Você pode seguir scripts semelhantes para aplicar DeBERTa aos seus próprios experimentos ou aplicativos. Os roteiros de pré-treinamento serão divulgados na próxima etapa.

Introdução ao DeBERTa

DeBERTa (BERT aprimorado por decodificação com atenção desembaraçada) melhora os modelos BERT e RoBERTa usando duas novas técnicas. O primeiro é o mecanismo de atenção desembaraçada, onde cada palavra é representada por dois vetores que codificam seu conteúdo e posição, respectivamente, e os pesos de atenção entre as palavras são calculados por meio de matrizes desembaraçadas em seu conteúdo e posições relativas. Em segundo lugar, um decodificador de máscara aprimorado é usado para substituir a camada softmax de saída para prever os tokens mascarados para o pré-treinamento do modelo. Mostramos que essas duas técnicas melhoram significativamente a eficiência do pré-treinamento do modelo e o desempenho das tarefas posteriores.

Modelos pré-treinados

Nossos modelos pré-treinados são compactados em arquivos compactados. Você pode baixá-los de nossos lançamentos ou baixar um modelo individual através dos links abaixo:

Modelo Vocabulário (K) Parâmetros de backbone (M) Tamanho oculto Camadas Observação
V2-XXLGrande 1 128 1320 1536 48 128 mil novos vocabulários SPM
V2-XLGrande 128 710 1536 24 128 mil novos vocabulários SPM
Extra Grande 50 700 1024 48 Mesmo vocabulário de RoBERTa
Grande 50 350 1024 24 Mesmo vocabulário de RoBERTa
Base 50 100 768 12 Mesmo vocabulário de RoBERTa
V2-XXLgrande-MNLI 128 1320 1536 48 Acabamento fino com MNLI
V2-XLarge-MNLI 128 710 1536 24 Acabamento fino com MNLI
XLarge-MNLI 50 700 1024 48 Acabamento fino com MNLI
Grande-MNLI 50 350 1024 24 Acabamento fino com MNLI
Base-MNLI 50 86 768 12 Acabamento fino com MNLI
DeBERTa -V3-Grande 2 128 304 1024 24 128 mil novos vocabulários SPM
DeBERTa -V3-Base 2 128 86 768 12 128 mil novos vocabulários SPM
DeBERTa -V3-Pequeno 2 128 44 768 6 128 mil novos vocabulários SPM
DeBERTa -V3-XSmall 2 128 22 384 12 128 mil novos vocabulários SPM
m DeBERTa -V3-Base 2 250 86 768 12 250 mil novos vocabulários SPM, modelo multilíngue com 102 idiomas

Observação

  • 1 Este é o modelo (89,9) que superou o T5 11B (89,3) e o desempenho humano (89,8) no SuperGLUE pela primeira vez. Novo vocabulário SPM de 128 mil.
  • 2 Esses modelos DeBERTa V3 são modelos DeBERTa pré-treinados com objetivo estilo ELECTRA mais compartilhamento de incorporação desembaraçado de gradiente que melhora significativamente a eficiência do modelo.

Experimente o modelo

Leia nossa documentação

Requisitos

  • Sistema Linux, por exemplo, Ubuntu 18.04LTS
  • CUDA10.0
  • Pytorch 1.3.0
  • píton 3.6
  • shell bash 4.0
  • enrolar
  • janela de encaixe (opcional)
  • nvidia-docker2 (opcional)

Existem várias maneiras de testar nosso código,

Usar janela de encaixe

Docker é a maneira recomendada de executar o código, pois já construímos todas as dependências em nosso docker bagai/ DeBERTa e você pode seguir o site oficial do docker para instalar o docker em sua máquina.

Para executar com o docker, certifique-se de que seu sistema atenda aos requisitos da lista acima. Aqui estão as etapas para testar os experimentos GLUE: Extraia o código, execute ./run_docker.sh e, em seguida, você pode executar os comandos bash em / DeBERTa /experiments/glue/

Usar pip

Extraia o código e execute pip3 install -r requirements.txt no diretório raiz do código, em seguida, insira a pasta experiments/glue/ do código e tente os comandos bash nessa pasta para experimentos de cola.

Instalar como um pacote pip

pip install DeBERTa

Use DeBERTa em código existente

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 )
}

Execute experimentos DeBERTa na linha de comando

Para tarefas de colagem,

  1. Obtenha os dados
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. Executar tarefa
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

Notas

    1. Por padrão, armazenaremos em cache o modelo pré-treinado e o tokenizer em $HOME/.~ DeBERTa , pode ser necessário limpá-lo se o download falhar inesperadamente.
    1. Você também pode experimentar nossos modelos com transformadores HF. Mas quando você tenta o modelo XXLarge, você precisa especificar o argumento --sharded_ddp. Por favor, verifique nosso cartão modelo XXLarge para mais detalhes.

Experimentos

Nossos experimentos de ajuste fino são realizados em meio nó DGX-2 com placas GPU 8x32 V100, os resultados podem variar devido a diferentes modelos de GPU, drivers, versões CUDA SDK, usando FP16 ou FP32 e sementes aleatórias. Relatamos nossos números com base em múltiplas execuções com diferentes sementes aleatórias aqui. Aqui estão os resultados do modelo Grande:

Tarefa Comando Resultados Tempo de execução (GPUs 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 2h50
MNLI grande experiments/glue/mnli.sh xlarge 91,5/91,2 +/-0,1 2h50
MNLI grande experiments/glue/mnli.sh large 91,3/91,1 +/-0,1 2h50
QQP grande experiments/glue/qqp.sh large 92,3 +/-0,1 6h
QNLI grande experiments/glue/qnli.sh large 95,3 +/-0,2 2h
MRPC grande experiments/glue/mrpc.sh large 91,9 +/-0,5 0,5h
RTE grande experiments/glue/rte.sh large 86,6 +/-1,0 0,5h
SST-2 grande experiments/glue/sst2.sh large 96,7 +/-0,3 1h
STS-b grande experiments/glue/Stsb.sh large 92,5 +/-0,3 0,5h
CoLA grande experiments/glue/cola.sh 70,5 +/-1,0 0,5h

E aqui estão os resultados do modelo Base

Tarefa Comando Resultados Tempo de execução (GPUs 8x32G V100)
Base MNLI experiments/glue/mnli.sh base 88,8/88,5 +/-0,2 1h50

Ajuste fino em tarefas NLU

Apresentamos os resultados de desenvolvimento no SQuAD 1.1/2.0 e diversas tarefas de benchmark do GLUE.

Modelo ESQUADRÃO 1.1 ESQUADRÃO 2.0 MNLI-m/mm SST-2 QNLI Cola RTE MRPC QQP STS-B
F1/EM F1/EM conta conta conta MCC conta Acc/F1 Acc/F1 P/S
BERT-Grande 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-Grande 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-Grande 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 -Grande 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-Grande --/- 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-Pequeno --/- 82,9/80,4 88,3/87,7 - - - - - - -
DeBERTa -V3-XSmall --/- 84,8/82,0 88,1/88,3 - - - - - - -

Ajuste fino no XNLI

Apresentamos os resultados de desenvolvimento no XNLI com configuração de transferência crosslingual zero-shot, ou seja, treinamento apenas com dados em inglês, teste em outros idiomas.

Modelo média pt franco é de el obrigado ru tr ar vi o z oi sw você
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

Notas.

  • 1 Seguindo RoBERTa, para RTE, MRPC, STS-B, ajustamos as tarefas com base em DeBERTa -Large-MNLI, DeBERTa -XLarge-MNLI, DeBERTa -V2-XLarge-MNLI, DeBERTa -V2-XXLarge-MNLI. Os resultados de SST-2/QQP/QNLI/SQuADv2 também serão ligeiramente melhorados ao partir de modelos ajustados de MNLI, no entanto, relatamos apenas os números ajustados de modelos básicos pré-treinados para essas 4 tarefas.

Pré-formação com objetivos de MLM e IDT

Para pré-treinar DeBERTa com objetivos de MLM e RTD, verifique experiments/language_models

Contatos

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

Citação

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}
}
Expandir
Informações adicionais
Aplicativos Relacionados
Recomendado para você
Informações Relacionadas Todos