UER py
1.0.0
Englisch |中文
Das Vortraining ist zu einem wesentlichen Bestandteil für NLP-Aufgaben geworden. UER-py (Universal Encoder Representations) ist ein Toolkit für das Vortraining für allgemeine Domänenkorpus und die Feinabstimmung für nachgelagerte Aufgaben. UER-py behält die Modellmodularität bei und unterstützt die Erweiterbarkeit der Forschung. Es erleichtert die Verwendung vorhandener Pre-Training-Modelle und bietet Benutzeroberflächen zur weiteren Erweiterung. Mit UER-py bauen wir einen Modellzoo auf, der vorab trainierte Modelle mit unterschiedlichen Eigenschaften enthält. Die vollständige Dokumentation finden Sie im UER-py-Projekt-Wiki .
Wir haben TencentPretrain, eine überarbeitete neue Version von UER-py, als Open-Source-Lösung bereitgestellt. TencentPretrain unterstützt multimodale Modelle und ermöglicht das Training großer Modelle. Wenn Sie sich für Textmodelle mittlerer Größe (mit Parametergrößen von weniger als einer Milliarde) interessieren, empfehlen wir Ihnen, weiterhin das UER-py-Projekt zu verwenden.
UER-py verfügt über die folgenden Funktionen:
In diesem Abschnitt werden mehrere häufig verwendete Beispiele verwendet, um die Verwendung von UER-py zu demonstrieren. Weitere Einzelheiten finden Sie im Abschnitt „Anweisungen“. Wir verwenden zunächst BERT (ein Text-Pre-Training-Modell) für den Datensatz zur Stimmungsklassifizierung von Buchrezensionen. Wir trainieren das Modell vorab auf dem Buchrezensionskorpus und optimieren es dann anhand des Stimmungsklassifizierungsdatensatzes für Buchrezensionen. Es gibt drei Eingabedateien: Buchrezensionskorpus, Datensatz zur Stimmungsklassifizierung von Buchrezensionen und Vokabular. Alle Dateien sind in UTF-8 kodiert und in diesem Projekt enthalten.
Das Format des Korpus für BERT ist wie folgt (ein Satz pro Zeile und Dokumente werden durch Leerzeilen getrennt):
doc1-sent1
doc1-sent2
doc1-sent3
doc2-sent1
doc3-sent1
doc3-sent2
Der Korpus der Buchrezensionen wird aus dem Klassifizierungsdatensatz für Buchrezensionen ermittelt. Wir entfernen Beschriftungen und teilen eine Rezension von der Mitte aus in zwei Teile auf, um ein Dokument mit zwei Sätzen zu erstellen (siehe book_review_bert.txt im Corpora- Ordner).
Das Format des Klassifizierungsdatensatzes ist wie folgt:
label text_a
1 instance1
0 instance2
1 instance3
Label und Instanz werden durch t getrennt. Die erste Zeile ist eine Liste von Spaltennamen. Für die n-Wege-Klassifizierung sollte die Label-ID eine ganze Zahl zwischen (einschließlich) 0 und n-1 sein.
Wir verwenden die chinesische Vokabeldatei models/google_zh_vocab.txt von Google, die 21128 chinesische Schriftzeichen enthält.
Wir bereiten zunächst den Korpus der Buchrezensionen vor. In der Vorverarbeitungsphase muss der Korpus in das Format verarbeitet werden, das für das angegebene Vortrainingsmodell ( --data_processor ) erforderlich ist:
python3 preprocess.py --corpus_path corpora/book_review_bert.txt --vocab_path models/google_zh_vocab.txt
--dataset_path dataset.pt --processes_num 8 --data_processor bert
Beachten Sie, dass six>=1.12.0 erforderlich ist.
Die Vorverarbeitung ist zeitaufwändig. Die Verwendung mehrerer Prozesse kann die Vorverarbeitungsgeschwindigkeit erheblich beschleunigen ( --processes_num ). Standardmäßig wird der BERT-Tokenizer verwendet ( --tokenizer bert ). Nach der Vorverarbeitung wird der Rohtext in dataset.pt konvertiert, was die Eingabe von pretrain.py ist. Dann laden wir Googles vorab trainiertes chinesisches BERT-Modell google_zh_model.bin herunter (im UER-Format und das Originalmodell stammt von hier) und legen es im Modellordner ab. Wir laden das vorab trainierte chinesische BERT-Modell und trainieren es weiter auf dem Buchrezensionskorpus. Das vorab trainierte Modell besteht normalerweise aus Einbettungs-, Encoder- und Zielebenen. Um ein Pre-Training-Modell zu erstellen, sollten wir entsprechende Informationen bereitstellen. Die Konfigurationsdatei ( --config_path ) gibt die Module und Hyperparameter an, die von Modellen vor dem Training verwendet werden. Weitere Details finden Sie in models/bert/base_config.json . Angenommen, wir haben eine Maschine mit 8 GPUs:
python3 pretrain.py --dataset_path dataset.pt --vocab_path models/google_zh_vocab.txt
--pretrained_model_path models/google_zh_model.bin
--config_path models/bert/base_config.json
--output_model_path models/book_review_model.bin
--world_size 8 --gpu_ranks 0 1 2 3 4 5 6 7
--total_steps 5000 --save_checkpoint_steps 1000 --batch_size 32
mv models/book_review_model.bin-5000 models/book_review_model.bin
Beachten Sie, dass das von pretrain.py trainierte Modell mit dem Suffix versehen ist, das den Trainingsschritt aufzeichnet ( --total_steps ). Aus Gründen der Benutzerfreundlichkeit könnten wir das Suffix entfernen.
Anschließend optimieren wir das vorab trainierte Modell anhand des nachgelagerten Klassifizierungsdatensatzes. Wir verwenden Einbettungs- und Encoderebenen von book_review_model.bin , der Ausgabe von pretrain.py :
python3 finetune/run_classifier.py --pretrained_model_path models/book_review_model.bin
--vocab_path models/google_zh_vocab.txt
--config_path models/bert/base_config.json
--train_path datasets/book_review/train.tsv
--dev_path datasets/book_review/dev.tsv
--test_path datasets/book_review/test.tsv
--epochs_num 3 --batch_size 32
Der Standardpfad des feinabgestimmten Klassifikatormodells lautet models/finetuned_model.bin . Es fällt auf, dass die tatsächliche Stapelgröße des Vortrainings --batch_size mal --world_size beträgt; Die tatsächliche Batchgröße der nachgelagerten Aufgabe (z. B. Klassifizierung) beträgt --batch_size . Dann ziehen wir Schlussfolgerungen mit dem fein abgestimmten Modell.
python3 inference/run_classifier_infer.py --load_model_path models/finetuned_model.bin
--vocab_path models/google_zh_vocab.txt
--config_path models/bert/base_config.json
--test_path datasets/book_review/test_nolabel.tsv
--prediction_path datasets/book_review/prediction.tsv
--labels_num 2
--test_path gibt den Pfad der vorherzusagenden Datei an. Die Datei sollte die Spalte text_a enthalten. --prediction_path gibt den Pfad der Datei mit Vorhersageergebnissen an. Wir müssen die Anzahl der Labels explizit mit --labels_num angeben. Der obige Datensatz ist ein bidirektionaler Klassifizierungsdatensatz.
Der obige Inhalt bietet grundlegende Möglichkeiten zur Verwendung von UER-py zur Vorverarbeitung, zum Vortraining, zur Feinabstimmung und zur Durchführung von Inferenzen. Weitere Anwendungsfälle finden Sie im vollständigen ➡️ Schnellstart ⬅️ . Der vollständige Schnellstart enthält zahlreiche Anwendungsfälle, die die meisten Anwendungsszenarien im Zusammenhang mit der Vorschulung abdecken. Es wird empfohlen, dass Benutzer den vollständigen Schnellstart lesen, um das Projekt sinnvoll nutzen zu können.
Dieser Abschnitt enthält Links zu einer Reihe von ➡️ Daten vor dem Training ⬅️. UER kann diese Pre-Training-Daten direkt laden.
Dieser Abschnitt enthält Links zu einer Reihe von ➡️ Downstream-Datensätzen ⬅️. UER kann diese Datensätze direkt laden.
Mit Hilfe von UER haben wir Modelle mit unterschiedlichen Eigenschaften vorab trainiert (z. B. Modelle, die auf verschiedenen Korpora, Encodern und Zielen basieren). Eine ausführliche Einführung vorab trainierter Modelle und deren Download-Links finden Sie in ➡️ modelzoo ⬅️. Alle vorab trainierten Modelle können direkt von UER geladen werden.
UER-py ist wie folgt organisiert:
UER-py/
|--uer/
| |--embeddings/ # contains modules of embedding component
| |--encoders/ # contains modules of encoder component such as RNN, CNN, Transformer
| |--decoders/ # contains modules of decoder component
| |--targets/ # contains modules of target component such as language modeling, masked language modeling
| |--layers/ # contains frequently-used NN layers
| |--models/ # contains model.py, which combines modules of different components
| |--utils/ # contains frequently-used utilities
| |--model_builder.py
| |--model_loader.py
| |--model_saver.py
| |--opts.py
| |--trainer.py
|
|--corpora/ # contains pre-training data
|--datasets/ # contains downstream tasks
|--models/ # contains pre-trained models, vocabularies, and configuration files
|--scripts/ # contains useful scripts for pre-training models
|--finetune/ # contains fine-tuning scripts for downstream tasks
|--inference/ # contains inference scripts for downstream tasks
|
|--preprocess.py
|--pretrain.py
|--README.md
|--README_ZH.md
|--requirements.txt
|--LICENSE
Der Code ist nach Komponenten organisiert (z. B. Einbettungen, Encoder). Benutzer können es mit geringem Aufwand nutzen und erweitern.
Umfassende Beispiele für die Verwendung von UER finden Sie in ➡️ Anleitungen ⬅️, die Benutzern helfen, vorab trainierte Modelle wie BERT, GPT-2, ELMo, T5 schnell zu implementieren und vorab trainierte Modelle für eine Reihe nachgelagerter Aufgaben zu optimieren.
UER-py wurde in den Siegerlösungen vieler NLP-Wettbewerbe eingesetzt. In diesem Abschnitt stellen wir einige Beispiele für die Verwendung von UER-py zur Erzielung von SOTA-Ergebnissen bei NLP-Wettbewerben wie CLUE vor. Ausführlichere Informationen finden Sie unter ➡️ Wettbewerbslösungen ⬅️.
@article{zhao2019uer,
title={UER: An Open-Source Toolkit for Pre-training Models},
author={Zhao, Zhe and Chen, Hui and Zhang, Jinbin and Zhao, Xin and Liu, Tao and Lu, Wei and Chen, Xi and Deng, Haotang and Ju, Qi and Du, Xiaoyong},
journal={EMNLP-IJCNLP 2019},
pages={241},
year={2019}
}
Für Kommunikation im Zusammenhang mit diesem Projekt wenden Sie sich bitte an Zhe Zhao ([email protected]; [email protected]) oder Yudong Li ([email protected]) oder Cheng Hou ([email protected]). oder Wenhang Shi ([email protected]).
Diese Arbeit wird von meinen Unternehmensmentoren Qi Ju , Xuefeng Yang , Haotang Deng und den Schulmentoren Tao Liu und Xiaoyong Du geleitet.
Wir bekamen auch viel Hilfe von Weijie Liu, Lusheng Zhang, Jianwei Cui, Xiayu Li, Weiquan Mao, Xin Zhao, Hui Chen, Jinbin Zhang, Zhiruo Wang, Peng Zhou, Haixiao Liu und Weijian Wu.
