DeBERTa Download – Download DeBERTa Quellcodes

DeBERTa

AI-Quellcode

1.0.0

Herunterladen

DeBERTa : Durch Dekodierung verbessertes BERT mit entwirrter Aufmerksamkeit

Dieses Repository ist die offizielle Implementierung von DeBERTa : Decoding - enhanced BERT with Disentangled A ttention und DeBERTa V3: Improving DeBERTa using ELECTRA-Style Pre-Training with Gradient-Disentangled Embedding Sharing

Nachricht

18.03.2023

DeBERTa V3-Papier wird von ICLR 2023 akzeptiert.
Der Code für DeBERTa V3-Vortraining und das kontinuierliche Training wurde hinzugefügt. Weitere Informationen finden Sie im Sprachmodell.

08.12.2021

DeBERTa -V3-XSmall wird hinzugefügt. Mit nur 22 Millionen Backbone-Parametern, was nur einem Viertel von RoBERTa-Base und XLNet-Base entspricht, übertrifft DeBERTa -V3-XSmall die späteren MNLI- und SQuAD v2.0-Aufgaben deutlich (d. h. 1,2 % auf MNLI-m, 1,5 % EM-Score). auf SQuAD v2.0). Dies ist ein weiterer Beweis für die Effizienz der DeBERTa V3-Modelle.

16.11.2021

Die Modelle unserer neuen Arbeit DeBERTa V3: Improving DeBERTa using ELECTRA-Style Pre-Training with Gradient-Disentangled Embedding Sharing sind jetzt öffentlich im Huggingface Model Hub verfügbar. Die neuen Modelle basieren auf DeBERTa -V2-Modellen, indem MLM durch Objektive im ELECTRA-Stil und eine gemeinsame Einbettung mit Gradientenentflechtung ersetzt wird, was die Modelleffizienz weiter verbessert.
Skripte für die Feinabstimmung DeBERTa V3-Modells wurden hinzugefügt
Code des RTD-Aufgabenleiters wurde hinzugefügt
Dokument für das Vortraining des Sprachmodells wurde hinzugefügt

31.03.2021

Die Aufgabe „Maskiertes Sprachmodell“ wurde hinzugefügt
SuperGLUE-Aufgaben wurden hinzugefügt
SiFT-Code wurde hinzugefügt

2.03.2021

DeBERTa v2-Code und das Modell 900M, 1.5B sind jetzt verfügbar. Dazu gehört auch das 1,5B-Modell, das für die Einreichung unseres SuperGLUE-Einzelmodells verwendet wurde und einen Wert von 89,9 im Vergleich zum menschlichen Basiswert von 89,8 erreichte. Weitere Details zu dieser Einreichung finden Sie in unserem Blog

Was ist neu in v2

Vokabular In Version 2 verwenden wir ein neues Vokabular der Größe 128 KB, das aus den Trainingsdaten erstellt wurde. Anstelle des GPT2-Tokenizers verwenden wir den Satzstück-Tokenizer.
nGiE (nGram Induced Input Encoding) In v2 verwenden wir neben der ersten Transformatorschicht eine zusätzliche Faltungsschicht, um die lokale Abhängigkeit von Eingabetokens besser zu lernen. Wir werden weitere Ablationsstudien zu dieser Funktion hinzufügen.
Teilen der Positionsprojektionsmatrix mit der Inhaltsprojektionsmatrix in der Aufmerksamkeitsebene Basierend auf unserem vorherigen Experiment haben wir festgestellt, dass dadurch Parameter eingespart werden können, ohne die Leistung zu beeinträchtigen.
Bucket anwenden, um relative Positionen zu codieren In Version 2 verwenden wir Log Bucket, um relative Positionen ähnlich wie in T5 zu codieren.
900M-Modell und 1,5B-Modell In Version 2 skalieren wir unsere Modellgröße auf 900M und 1,5B, was die Leistung nachgelagerter Aufgaben erheblich verbessert.

29.12.2020

Mit DeBERTa 1.5B-Modell übertreffen wir das T5 11B-Modell und die menschliche Leistung auf der SuperGLUE-Bestenliste. Code und Modell werden in Kürze veröffentlicht. Weitere Informationen finden Sie in unserem Dokument.

13.06.2020

Wir haben die vorab trainierten Modelle, den Quellcode und die Feinabstimmungsskripte veröffentlicht, um einige der experimentellen Ergebnisse im Artikel zu reproduzieren. Sie können ähnlichen Skripten folgen, um DeBERTa auf Ihre eigenen Experimente oder Anwendungen anzuwenden. Im nächsten Schritt werden Vorschulungsskripte veröffentlicht.

Einführung in DeBERTa

DeBERTa (Decoding-enhanced BERT with entwirrte Aufmerksamkeit) verbessert die BERT- und RoBERTa-Modelle mithilfe zweier neuartiger Techniken. Der erste ist der entwirrte Aufmerksamkeitsmechanismus, bei dem jedes Wort durch zwei Vektoren dargestellt wird, die seinen Inhalt bzw. seine Position kodieren, und die Aufmerksamkeitsgewichte zwischen Wörtern mithilfe entwirrter Matrizen für ihren Inhalt und ihre relativen Positionen berechnet werden. Zweitens wird ein erweiterter Maskendecoder verwendet, um die Ausgabe-Softmax-Ebene zu ersetzen und die maskierten Token für das Modell-Vortraining vorherzusagen. Wir zeigen, dass diese beiden Techniken die Effizienz des Modell-Vortrainings und die Leistung nachgelagerter Aufgaben erheblich verbessern.

Vorab trainierte Modelle

Unsere vorab trainierten Modelle sind in ZIP-Dateien verpackt. Sie können sie aus unseren Veröffentlichungen herunterladen oder über die folgenden Links ein einzelnes Modell herunterladen:

Modell	Wortschatz(K)	Backbone-Parameter (M)	Versteckte Größe	Schichten	Notiz
V2-XXLarge ¹	128	1320	1536	48	128.000 neue SPM-Vokabeln
V2-XLarge	128	710	1536	24	128.000 neue SPM-Vokabeln
XL	50	700	1024	48	Gleicher Wortschatz wie RoBERTa
Groß	50	350	1024	24	Gleicher Wortschatz wie RoBERTa
Base	50	100	768	12	Gleicher Wortschatz wie RoBERTa
V2-XXLarge-MNLI	128	1320	1536	48	Feingedreht mit MNLI
V2-XLarge-MNLI	128	710	1536	24	Feingedreht mit MNLI
XLarge-MNLI	50	700	1024	48	Feingedreht mit MNLI
Groß-MNLI	50	350	1024	24	Feingedreht mit MNLI
Basis-MNLI	50	86	768	12	Feingedreht mit MNLI
DeBERTa -V3-Large ²	128	304	1024	24	128.000 neue SPM-Vokabeln
DeBERTa -V3-Base ²	128	86	768	12	128.000 neue SPM-Vokabeln
DeBERTa -V3-Small ²	128	44	768	6	128.000 neue SPM-Vokabeln
DeBERTa -V3-XSmall ²	128	22	384	12	128.000 neue SPM-Vokabeln
m DeBERTa -V3-Base ²	250	86	768	12	250.000 neue SPM-Vokabeln, mehrsprachiges Modell mit 102 Sprachen

Notiz

1 Dies ist das Modell (89,9), das zum ersten Mal T5 11B (89,3) und die menschliche Leistung (89,8) mit SuperGLUE übertraf. 128.000 neue SPM-Vokabeln.
2 Bei diesen V3- DeBERTa Modellen handelt es sich um DeBERTa -Modelle, die vorab mit ELECTRA-ähnlichen Zielen und einer farbverlaufsentwirrten Einbettungsfreigabe trainiert wurden, was die Modelleffizienz erheblich verbessert.

Probieren Sie das Modell aus

Lesen Sie unsere Dokumentation

Anforderungen

Linux-System, z. B. Ubuntu 18.04LTS
CUDA 10.0
Pytorch 1.3.0
Python 3.6
Bash-Shell 4.0
Locken
Docker (optional)
nvidia-docker2 (optional)

Es gibt verschiedene Möglichkeiten, unseren Code auszuprobieren.

Verwenden Sie Docker

Docker ist die empfohlene Methode zum Ausführen des Codes, da wir bereits alle Abhängigkeiten in unser Docker-Bagai/ DeBERTa integriert haben und Sie der offiziellen Docker-Website folgen können, um Docker auf Ihrem Computer zu installieren.

Stellen Sie zur Ausführung mit Docker sicher, dass Ihr System die Anforderungen in der obigen Liste erfüllt. Hier sind die Schritte, um die GLUE-Experimente auszuprobieren: Ziehen Sie den Code, führen Sie ./run_docker.sh aus, und dann können Sie die Bash-Befehle unter / DeBERTa /experiments/glue/ ausführen.

Benutze Pip

Ziehen Sie den Code und führen Sie pip3 install -r requirements.txt im Stammverzeichnis des Codes aus. Geben Sie dann den Ordner experiments/glue/ des Codes ein und probieren Sie die Bash-Befehle in diesem Ordner für Kleberexperimente aus.

Als Pip-Paket installieren

pip install DeBERTa

Verwenden Sie DeBERTa in vorhandenem Code

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

Führen Sie DeBERTa -Experimente über die Befehlszeile aus

Für Klebearbeiten,

Holen Sie sich die Daten

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

Aufgabe ausführen

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

Notizen

1. Standardmäßig speichern wir das vorab trainierte Modell und den Tokenizer unter $HOME/.~ DeBERTa Möglicherweise müssen Sie es bereinigen, wenn der Download unerwartet fehlschlägt.
1. Sie können unsere Modelle auch mit HF-Transformatoren ausprobieren. Wenn Sie jedoch das XXLarge-Modell ausprobieren, müssen Sie das Argument --sharded_ddp angeben. Weitere Informationen finden Sie auf unserer XXLarge-Modellkarte.

Experimente

Unsere Feinabstimmungsexperimente werden auf einem halben DGX-2-Knoten mit 8x32 V100-GPU-Karten durchgeführt. Die Ergebnisse können aufgrund unterschiedlicher GPU-Modelle, Treiber, CUDA SDK-Versionen, Verwendung von FP16 oder FP32 und zufälliger Seeds variieren. Wir berichten hier über unsere Zahlen basierend auf mehreren Durchläufen mit unterschiedlichen Zufallsstartwerten. Hier sind die Ergebnisse des großen Modells:

Aufgabe	Befehl	Ergebnisse	Laufzeit (8x32G V100 GPUs)
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	2,5h
MNLI xlarge	`experiments/glue/mnli.sh xlarge`	91,5/91,2 +/-0,1	2,5h
MNLI groß	`experiments/glue/mnli.sh large`	91,3/91,1 +/-0,1	2,5h
QQP groß	`experiments/glue/qqp.sh large`	92,3 +/-0,1	6h
QNLI groß	`experiments/glue/qnli.sh large`	95,3 +/-0,2	2h
MRPC groß	`experiments/glue/mrpc.sh large`	91,9 +/-0,5	0,5h
RTE groß	`experiments/glue/rte.sh large`	86,6 +/-1,0	0,5h
SST-2 groß	`experiments/glue/sst2.sh large`	96,7 +/-0,3	1h
STS-b groß	`experiments/glue/Stsb.sh large`	92,5 +/-0,3	0,5h
CoLA groß	`experiments/glue/cola.sh`	70,5 +/-1,0	0,5h

Und hier sind die Ergebnisse des Basismodells

Aufgabe	Befehl	Ergebnisse	Laufzeit (8x32G V100 GPUs)
MNLI-Basis	`experiments/glue/mnli.sh base`	88,8/88,5 +/-0,2	1,5h

Feinabstimmung der NLU-Aufgaben

Wir präsentieren die Entwicklungsergebnisse zu SQuAD 1.1/2.0 und mehreren GLUE-Benchmark-Aufgaben.

Modell	SQuAD 1.1	SQuAD 2.0	MNLI-m/mm	SST-2	QNLI	Cola	RTE	MRPC	QQP	STS-B
	F1/EM	F1/EM	Acc	Acc	Acc	MCC	Acc	Acc/F1	Acc/F1	P/S
BERT-Groß	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-Groß	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-Groß	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 -Groß ¹	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 ¹	-/-	-/-	91,5/91,2	97,0	-	-	93.1	92,1/94,3	-	92,9/92,7
DeBERTa -V2-XLarge ¹	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-Groß	-/-	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-Small	-/-	82,9/80,4	88,3/87,7	-	-	-	-	-	-	-
DeBERTa -V3-XSmall	-/-	84,8/82,0	88,1/88,3	-	-	-	-	-	-	-

Feinabstimmung auf XNLI

Wir präsentieren die Entwicklungsergebnisse auf XNLI mit der Einstellung „Zero-Shot Crosslingual Transfer“, d. h. Training nur mit englischen Daten, Test in anderen Sprachen.

Modell	Durchschn	de	fr	es	de	el	bg	ru	tr	ar	vi	Th	zh	Hi	sw	ur
XLM-R-Basis	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

Notizen.

¹ Im Anschluss an RoBERTa optimieren wir für RTE, MRPC und STS-B die Aufgaben basierend auf DeBERTa -Large-MNLI, DeBERTa -XLarge-MNLI, DeBERTa -V2-XLarge-MNLI, DeBERTa -V2-XXLarge-MNLI. Die Ergebnisse von SST-2/QQP/QNLI/SQuADv2 werden auch leicht verbessert, wenn mit fein abgestimmten MNLI-Modellen begonnen wird. Für diese vier Aufgaben berichten wir jedoch nur über die Zahlen, die anhand vorab trainierter Basismodelle fein abgestimmt wurden.

Vorschulung mit MLM- und RTD-Zielen

Um DeBERTa vorab mit MLM- und RTD-Zielen zu trainieren, überprüfen Sie bitte experiments/language_models

Kontakte

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

Zitat

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

Expandieren

Zusätzliche Informationen

Version 1.0.0
Typ AI-Quellcode
Aktualisierungszeit 2024-12-31
Größe 50MB
Kommt von Github

Ähnliche Anwendungen

node telegram bot api

2024-12-14
typebot.io

2024-12-14
python wechaty getting started

2024-12-14
TranscriberBot

2024-12-14
genal chat

2024-12-14
Facemoji

2024-12-14