xlnet_sequence_tagging
1.0.0
Wir entwickeln dieses Projekt, um Aufgaben zu markieren, die NLPER immer erfüllt.
Verwenden Sie XLNET für folgende Aufgaben
Alarm, diese Codes sind noch nicht fertig. Vorsichtig sein zu verwenden.
Führen Sie beispielsweise die Scipts mit: Führen Sie mit:
python2.7 /home/dev/Documents/xlnet-master/run_blstm_crf-run_race.py
--use_tpu
--model_config_path /home/dev/Documents/xlnet_models/xlnet_cased_L-12_H-768_A-12/xlnet_config.json
--spiece_model_file /home/dev/Documents/xlnet_models/xlnet_cased_L-12_H-768_A-12/spiece.model
--model_dir /home/dev/Documents/xlnet_models/finetuned/
--data_dir /home/dev/Documents/udify-master/data/ud/xlnet_data/
--do_train True
--save_steps 2
--output_dir /home/dev/Documents/xlnet_models/output_dir https://universaldependencies.org/
Sie können "Find ./ -Name *test/dev/train.conll" verwenden, um alle Conll -Dateien zu finden und mit XARGS nach Data_dir zu kopieren
https://github.com/yuchenlin/ontonotes-5.0-ner-bio
Kopieren Sie einfach die englischen Dateien mit der Python -Skriptdatei in data_dir: onotonotes_conll_copyfile.py (Sie müssen möglicherweise die Pfade ändern).
PR S sind willkommen! Bitte helfen Sie beim sich entwickelnden Projekt, um unsere NLP -Leistung zu verbessern!
XLNET ist eine neue Lernmethode für unbeaufsichtigte Sprachrepräsentation, die auf einem neuartigen Permutationssprachenmodellierungsziel basiert. Darüber hinaus verwendet XLNET Transformator-XL als Backbone-Modell und weist eine hervorragende Leistung für Sprachaufgaben auf, die einen langen Kontext beinhalten. Insgesamt erzielt XLNET auf verschiedenen nachgeschalteten Sprachaufgaben, darunter Fragenbeantwortung, Inferenz, Stimmungsanalyse und Dokumentranking, hochmoderne Ergebnisse (SOTA).
Eine detaillierte Beschreibung technischer Details und experimenteller Ergebnisse finden Sie in unserem Artikel:
XLNET: Verallgemeinerte autoregressive Vorbereitung für das Sprachverständnis
Zhilin Yang*, Zihang Dai*, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, Quoc V. Le
(*: Gleicher Beitrag)
Preprint 2019
Zum 19. Juni 2019 übertrifft XLNET Bert bei 20 Aufgaben und erzielt hochmoderne Ergebnisse bei 18 Aufgaben. Im Folgenden finden Sie einen Vergleich zwischen XLNET-Large und Bert-Large, die ähnliche Modellgrößen haben:
| Modell | Rassengenauigkeit | Squad1.1 Em | Squad2.0 em |
|---|---|---|---|
| Bert-Large | 72.0 | 84.1 | 78,98 |
| Xlnet-Base | 80.18 | ||
| Xlnet-large | 81.75 | 88.95 | 86.12 |
Wir verwenden Squad Dev -Ergebnisse in der Tabelle, um andere Faktoren auszuschließen, z. B. zusätzliche Trainingsdaten oder andere Datenerweiterungstechniken. In der Squad Ranging Bohring für Testnummern.
| Modell | IMDB | Yelp-2 | Yelp-5 | Dbpedia | Amazon-2 | Amazon-5 |
|---|---|---|---|---|---|---|
| Bert-Large | 4.51 | 1.89 | 29.32 | 0,64 | 2.63 | 34.17 |
| Xlnet-large | 3.79 | 1,55 | 27.80 | 0,62 | 2.40 | 32.26 |
Die obigen Zahlen sind Fehlerraten.
| Modell | Mnli | Qnli | QQP | Rte | SST-2 | MRPC | Cola | STS-B |
|---|---|---|---|---|---|---|---|---|
| Bert-Large | 86.6 | 92.3 | 91.3 | 70,4 | 93.2 | 88.0 | 60.6 | 90.0 |
| Xlnet-Base | 86,8 | 91.7 | 91.4 | 74,0 | 94.7 | 88.2 | 60.2 | 89,5 |
| Xlnet-large | 89,8 | 93.9 | 91.8 | 83.8 | 95.6 | 89,2 | 63.6 | 91.8 |
In der Tabelle werden Einzelaufgaben-Dev-Ergebnisse verwendet, um andere Faktoren wie das Lernen von Multitasking-Lernen oder die Verwendung von Ensembles auszuschließen.
Ab dem 16. Juli 2019 wurden die folgenden Modelle zur Verfügung gestellt:
XLNet-Large, Cased : 24-Layer, 1024 versteckte 16-KöpfeXLNet-Base, Cased : 12-Layer, 768 versteckte 12-Heads. Dieses Modell wird auf vollständigen Daten trainiert (anders als das im Papier).Wir veröffentlichen vorerst nur gedeckte Modelle, da wir bei den von uns in Betracht gezogenen Aufgaben: (1) für die Basiseinstellung festgestellt haben, dass die Modelle von Häken und ungezogenen Modellen eine ähnliche Leistung haben; (2) Für die große Einstellung sind die Modelle mit Häken bei einigen Aufgaben etwas besser.
Jede .zip -Datei enthält drei Elemente:
xlnet_model.ckpt ) enthält die vorgeborenen Gewichte (die tatsächlich 3 Dateien sind).spiece.model ), das für (DE) Tokenisierung verwendet wird.xlnet_config.json ), die die Hyperparameter des Modells angibt.Wir planen auch, kontinuierlich mehr vorgezogene Modelle unter verschiedenen Einstellungen freizusetzen, darunter:
Um Benachrichtigungen über Updates, Ankündigungen und Neuveröffentlichungen zu erhalten, empfehlen wir, das XLNET in Google Groups abonnieren.
Zum 19. Juni 2019 wurde diese Codebasis mit TensorFlow 1.13.1 unter Python2 getestet.
XLNet-Large SOTA-Ergebnisse in der Arbeit mit GPUs mit 12 GB-16 GB RAM neu zu produzieren, da eine 16-GB-GPU nur eine einzige Sequenz mit Länge 512 für XLNet-Large halten kann. Daher ist eine große Zahl (von 32 bis 128, gleich batch_size ) von GPUs erforderlich, um viele Ergebnisse im Papier zu reproduzieren. Angesichts des oben genannten Speicherproblems haben wir die maximale Stapelgröße einer einzelnen 16 -GB -GPU mit TensorFlow 1.13.1 mithilfe der Standard -Finetuning -Skripte ( run_classifier.py und run_squad.py ) die maximale Stapelgröße unterteilt:
| System | SEQ Länge | Max Batchgröße |
|---|---|---|
XLNet-Base | 64 | 120 |
| ... | 128 | 56 |
| ... | 256 | 24 |
| ... | 512 | 8 |
XLNet-Large | 64 | 16 |
| ... | 128 | 8 |
| ... | 256 | 2 |
| ... | 512 | 1 |
In den meisten Fällen ist es möglich, die Stapelgröße zu reduzieren train_batch_size oder die maximale Sequenzlänge max_seq_length so, dass sie in eine bestimmte Hardware passen. Die Leistungsabnahme hängt von der Aufgabe und den verfügbaren Ressourcen ab.
Der Code, der zur Durchführung von Klassifizierungs-/Regressionsfonetuning verwendet wird, befindet sich in run_classifier.py . Es enthält auch Beispiele für die Standardeinklassifizierung der Standard-Ein-Dokumente, eine Ein-Dokument-Regression und eine Dokumentpaarklassifizierung. Hier geben wir zwei konkrete Beispiele an, wie run_classifier.py verwendet werden kann.
Von hier aus gehen wir davon aus, dass XLNet-Large und XLNet-Base auf $LARGE_DIR bzw. $BASE_DIR heruntergeladen wurden.
Laden Sie die Klebendaten herunter, indem Sie dieses Skript ausführen und es in ein Verzeichnis $GLUE_DIR auspacken.
Führen Sie mit XLNET-Large durch Ausführen Multi-GPU (4 V100-GPUs) -Fonetuning durch
CUDA_VISIBLE_DEVICES=0,1,2,3 python run_classifier.py
--do_train=True
--do_eval=False
--task_name=sts-b
--data_dir= ${GLUE_DIR} /STS-B
--output_dir=proc_data/sts-b
--model_dir=exp/sts-b
--uncased=False
--spiece_model_file= ${LARGE_DIR} /spiece.model
--model_config_path= ${LARGE_DIR} /xlnet_config.json
--init_checkpoint= ${LARGE_DIR} /xlnet_model.ckpt
--max_seq_length=128
--train_batch_size=8
--num_hosts=1
--num_core_per_host=4
--learning_rate=5e-5
--train_steps=1200
--warmup_steps=120
--save_steps=600
--is_regression=TrueBewerten Sie die Finetuning -Ergebnisse mit einer einzelnen GPU durch
CUDA_VISIBLE_DEVICES=0 python run_classifier.py
--do_train=False
--do_eval=True
--task_name=sts-b
--data_dir= ${GLUE_DIR} /STS-B
--output_dir=proc_data/sts-b
--model_dir=exp/sts-b
--uncased=False
--spiece_model_file= ${LARGE_DIR} /spiece.model
--model_config_path= ${LARGE_DIR} /xlnet_config.json
--max_seq_length=128
--eval_batch_size=8
--num_hosts=1
--num_core_per_host=1
--eval_all_ckpt=True
--is_regression=True
# Expected performance: "eval_pearsonr 0.916+ "Anmerkungen :
num_core_per_host die Anzahl der zu verwendenden GPUs.train_batch_size auf die Größe pro GPU.eval_all_ckpt können nach dem Training alle gespeicherten Kontrollpunkte bewertet werden (die Sparfrequenz wird von save_steps gesteuert) und das beste Modell basierend auf der Entwicklungsleistung auszuwählen.data_dir und output_dir beziehen sich auf die Verzeichnisse der "Rohdaten" bzw. "vorverarbeiteten TFRecords", während model_dir das Arbeitsverzeichnis zum Speichern von Kontrollpunkten und Tensorflow -Ereignissen ist. model_dir sollte als separates Ordner für init_checkpoint festgelegt werden.--train_batch_size=32 und --num_core_per_host=1 , zusammen mit Änderungen in init_checkpoint und model_config_path .train_batch_size und erhöhen Sie num_core_per_host , um dieselbe Trainingseinstellung zu verwenden.Laden Sie den IMDB -Datensatz durch Ausführen herunter und packen Sie sie aus
wget http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz
tar zxvf aclImdb_v1.tar.gzStarten Sie eine Google Cloud-TPU-V3-8-Instanz (finden Sie im TPU-Tutorial von Google Cloud für die Einrichtung von Cloud-TPUs).
Richten Sie Ihren Google Storage Bucket -Pfad $GS_ROOT ein und verschieben Sie den IMDB -Datensatz und den vorgezogenen Kontrollpunkt in Ihren Google -Speicher.
Führen Sie TPU-Finetuning mit XLNet-Large durch Ausführen durch
python run_classifier.py
--use_tpu=True
--tpu= ${TPU_NAME}
--do_train=True
--do_eval=True
--eval_all_ckpt=True
--task_name=imdb
--data_dir= ${IMDB_DIR}
--output_dir= ${GS_ROOT} /proc_data/imdb
--model_dir= ${GS_ROOT} /exp/imdb
--uncased=False
--spiece_model_file= ${LARGE_DIR} /spiece.model
--model_config_path= ${GS_ROOT} / ${LARGE_DIR} /model_config.json
--init_checkpoint= ${GS_ROOT} / ${LARGE_DIR} /xlnet_model.ckpt
--max_seq_length=512
--train_batch_size=32
--eval_batch_size=8
--num_hosts=1
--num_core_per_host=8
--learning_rate=2e-5
--train_steps=4000
--warmup_steps=500
--save_steps=500
--iterations=500
# Expected performance: "eval_accuracy 0.962+ "Anmerkungen :
data_dir und spiece_model_file beide eher einen lokalen Pfad als einen Google -Speicherpfad verwenden. Der Grund dafür ist, dass die Datenvorverarbeitung tatsächlich lokal durchgeführt wird. Daher führt die Verwendung lokaler Pfade zu einer schnelleren Vorverarbeitungsgeschwindigkeit. Der Code für den Squad -Datensatz ist in run_squad.py enthalten.
Um den Code auszuführen:
(1) Laden Sie den Squad2.0 -Datensatz in $SQUAD_DIR nach: herunter.
mkdir -p ${SQUAD_DIR} && cd ${SQUAD_DIR}
wget https://rajpurkar.github.io/SQuAD-explorer/dataset/train-v2.0.json
wget https://rajpurkar.github.io/SQuAD-explorer/dataset/dev-v2.0.json (2) Führen Sie die Datenvorverarbeitung mit den scripts/prepro_squad.sh durch.
Dies dauert einige Zeit, um Charakterpositionen (Rohdaten) genau auf Satzpositionen (für das Training) genau zu kartieren.
Für schnellere parallele Vorverarbeitung finden Sie in den Flags --num_proc und --proc_id in run_squad.py .
(3) Training und Bewertung durchführen.
Für die beste Leistung verwendet XLnet-Large die Sequenzlänge 512 und die Stapelgröße 48 für das Training.
Infolgedessen ist es ziemlich schwierig, das beste Ergebnis mit GPUs zu reproduzieren.
Für das Training mit einem TPU V3-8 kann man einfach die scripts/tpu_squad_large.sh ausführen, nachdem sowohl die TPU als auch der Google-Speicher eingerichtet wurden.
run_squad.py führt automatisch die Schwellenwerte auf dem Dev -Set von Kader durch und gibt die Punktzahl aus. Mit scripts/tpu_squad_large.sh sollte die erwartete F1 -Punktzahl bei 88,6 liegen (Median unserer mehreren Läufe).
Alternativ kann man XLNET-Base mit GPUs (z. B. drei V100) verwenden. Ein Satz angemessener Hyperparameter finden Sie in den scripts/gpu_squad_base.sh .
Der Code für das Rennen für das Leseverständnis -Task ist in run_race.py enthalten.
Um den Code auszuführen:
(1) Laden Sie den Renndatensatz von der offiziellen Website herunter und packen Sie die Rohdaten auf $RACE_DIR aus.
(2) Training und Bewertung durchführen:
script/tpu_race_large_bsz32.sh für diese Einstellung.script/tpu_race_large_bsz8.sh ).Ein Beispiel für die Verwendung von Google Colab mit GPUs wurde bereitgestellt. Beachten Sie, dass die Ergebnisse, da die Hardware im Beispiel eingeschränkt ist, schlechter sind als die besten, die wir erhalten können. Es dient hauptsächlich als Beispiel und sollte entsprechend geändert werden, um die Leistung zu maximieren.
Für die Finetuning ist es wahrscheinlich, dass Sie vorhandene Dateien wie run_classifier.py , run_squad.py und run_race.py für Ihre jeweilige Aufgabe ändern können. Wir bieten jedoch auch eine Abstraktion von XLNET, um eine flexiblere Verwendung zu ermöglichen. Unten ist ein Beispiel:
import xlnet
# some code omitted here...
# initialize FLAGS
# initialize instances of tf.Tensor, including input_ids, seg_ids, and input_mask
# XLNetConfig contains hyperparameters that are specific to a model checkpoint.
xlnet_config = xlnet . XLNetConfig ( json_path = FLAGS . model_config_path )
# RunConfig contains hyperparameters that could be different between pretraining and finetuning.
run_config = xlnet . create_run_config ( is_training = True , is_finetune = True , FLAGS = FLAGS )
# Construct an XLNet model
xlnet_model = xlnet . XLNetModel (
xlnet_config = xlnet_config ,
run_config = run_config ,
input_ids = input_ids ,
seg_ids = seg_ids ,
input_mask = input_mask )
# Get a summary of the sequence using the last hidden state
summary = xlnet_model . get_pooled_out ( summary_type = "last" )
# Get a sequence output
seq_out = xlnet_model . get_sequence_output ()
# build your applications based on `summary` or `seq_out`Nachfolgend finden Sie ein Beispiel für eine Tokenisierung in XLNET:
import sentencepiece as spm
from prepro_utils import preprocess_text , encode_ids
# some code omitted here...
# initialize FLAGS
text = "An input text string."
sp_model = spm . SentencePieceProcessor ()
sp_model . Load ( FLAGS . spiece_model_file )
text = preprocess_text ( text , lower = FLAGS . uncased )
ids = encode_ids ( sp_model , text ) wobei FLAGS.spiece_model_file die Satzstückmodelldatei im selben Reißverschluss wie das vorbereitete Modell ist, ist FLAGS.uncased ein BOOL, das angibt, ob es sich um Uncasing handelt.
train_gpu.py train.py . Zunächst müssen wir die Textdaten in TFRECORDS vorbereiten.
python data_utils.py
--bsz_per_host=32
--num_core_per_host=16
--seq_len=512
--reuse_len=256
--input_glob= * .txt
--save_dir= ${SAVE_DIR}
--num_passes=20
--bi_data=True
--sp_path=spiece.model
--mask_alpha=6
--mask_beta=1
--num_predict=85 Wenn input_glob alle Eingabetextdateien definiert, ist save_dir das Ausgabeverzeichnis für TFRECORDS, und sp_path ist ein Satz -Stück -Modell. Hier ist unser Drehbuch, um das Satzstück zu trainieren
spm_train
--input= $INPUT
--model_prefix=sp10m.cased.v3
--vocab_size=32000
--character_coverage=0.99995
--model_type=unigram
--control_symbols= < cls > , < sep > , < pad > , < mask > , < eod >
--user_defined_symbols= < eop > ,.,(,), " ,-,–,£,€
--shuffle_input_sentence
--input_sentence_size=10000000 Es werden spezielle Symbole verwendet, einschließlich control_symbols und user_defined_symbols . Wir verwenden <eop> und <eod> , um das Ende des Absatzes und des Ende des Dokuments zu bezeichnen.
Die Eingabe von Textdateien in data_utils.py müssen das folgende Format verwenden:
<eop> am Ende bestimmter Zeilen (ohne Platz) eingefügt werden, um anzuzeigen, dass der entsprechende Satz einen Absatz beendet.Beispielsweise könnte die Texteingabedatei sein:
This is the first sentence.
This is the second sentence and also the end of the paragraph.<eop>
Another paragraph.
Another document starts here.
Nach der Vorverarbeitung sind wir bereit, einen XLNET vorzubereiten. Im Folgenden finden Sie die Hyperparameter, die für das Vorab-XLNET-Large verwendet werden:
python train.py
--record_info_dir= $DATA /tfrecords
--train_batch_size=2048
--seq_len=512
--reuse_len=256
--mem_len=384
--perm_size=256
--n_layer=24
--d_model=1024
--d_embed=1024
--n_head=16
--d_head=64
--d_inner=4096
--untie_r=True
--mask_alpha=6
--mask_beta=1
--num_predict=85Wenn wir nur die wichtigsten Flags und die anderen Flags auflisten, können sie basierend auf bestimmten Anwendungsfällen angepasst werden.
