UER py
1.0.0
Anglais |中文
La pré-formation est devenue un élément essentiel des tâches de PNL. UER-py (Universal Encoder Representations) est une boîte à outils pour la pré-formation sur le corpus du domaine général et le réglage fin des tâches en aval. UER-py maintient la modularité du modèle et prend en charge l'extensibilité de la recherche. Il facilite l'utilisation des modèles de pré-formation existants et fournit des interfaces permettant aux utilisateurs de les développer davantage. Avec UER-py, nous construisons un zoo modèle qui contient des modèles pré-entraînés de différentes propriétés. Voir le wiki du projet UER-py pour une documentation complète .
Nous avons open source TencentPretrain, une nouvelle version refactorisée d'UER-py. TencentPretrain prend en charge les modèles multimodaux et permet la formation de grands modèles. Si vous êtes intéressé par des modèles de texte de taille moyenne (avec des tailles de paramètres inférieures à un milliard), nous vous recommandons de continuer à utiliser le projet UER-py.
UER-py a les fonctionnalités suivantes :
Cette section utilise plusieurs exemples couramment utilisés pour montrer comment utiliser UER-py. Plus de détails sont discutés dans la section Instructions. Nous utilisons d'abord BERT (un modèle de pré-formation de texte) sur un ensemble de données de classification des sentiments des critiques de livres. Nous pré-entraînons le modèle sur le corpus de critiques de livres, puis l'affinons sur l'ensemble de données de classification des sentiments des critiques de livres. Il existe trois fichiers d'entrée : le corpus des critiques de livres, l'ensemble de données de classification des sentiments des critiques de livres et le vocabulaire. Tous les fichiers sont codés en UTF-8 et inclus dans ce projet.
Le format du corpus pour BERT est le suivant (une phrase par ligne et les documents sont délimités par des lignes vides) :
doc1-sent1
doc1-sent2
doc1-sent3
doc2-sent1
doc3-sent1
doc3-sent2
Le corpus des critiques de livres est obtenu à partir d’un ensemble de données de classification des critiques de livres. Nous supprimons les étiquettes et divisons une critique en deux parties à partir du milieu pour construire un document avec deux phrases (voir book_review_bert.txt dans le dossier corpus ).
Le format de l'ensemble de données de classification est le suivant :
label text_a
1 instance1
0 instance2
1 instance3
L'étiquette et l'instance sont séparées par t . La première ligne est une liste de noms de colonnes. L’ID de l’étiquette doit être un nombre entier compris entre (et inclus) 0 et n-1 pour la classification à n voies.
Nous utilisons le fichier de vocabulaire chinois de Google models/google_zh_vocab.txt , qui contient 21 128 caractères chinois.
Nous pré-traitons dans un premier temps le corpus des critiques de livres. Lors de la phase de pré-traitement, le corpus doit être traité dans le format requis par le modèle de pré-formation spécifié ( --data_processor ) :
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
Notez que six>=1.12.0 est requis.
Le prétraitement prend du temps. L'utilisation de plusieurs processus peut considérablement accélérer la vitesse de prétraitement ( --processes_num ). Le tokenizer BERT est utilisé par défaut ( --tokenizer bert ). Après le prétraitement, le texte brut est converti en dataset.pt , qui est l'entrée de pretrain.py . Ensuite, nous téléchargeons le modèle BERT chinois pré-entraîné de Google, google_zh_model.bin (au format UER et le modèle original provient d'ici), et le plaçons dans le dossier models . Nous chargeons le modèle BERT chinois pré-entraîné et le pré-entraînons davantage sur le corpus de critiques de livres. Le modèle de pré-entraînement est généralement composé de couches d'intégration, d'encodeur et cible. Pour construire un modèle de pré-formation, nous devons fournir des informations connexes. Le fichier de configuration ( --config_path ) spécifie les modules et hyper-paramètres utilisés par les modèles de pré-formation. Plus de détails peuvent être trouvés dans models/bert/base_config.json . Supposons que nous ayons une machine avec 8 GPU :
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
Notez que le modèle entraîné par pretrain.py est attaché avec le suffixe qui enregistre l'étape d'entraînement ( --total_steps ). Nous pourrions supprimer le suffixe pour faciliter l'utilisation.
Ensuite, nous affinons le modèle pré-entraîné sur l'ensemble de données de classification en aval. Nous utilisons les couches d'intégration et d'encodage de book_review_model.bin , qui est la sortie de 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
Le chemin par défaut du modèle de classificateur affiné est models/finetuned_model.bin . Il est à noter que la taille réelle du lot de pré-formation est de --batch_size fois --world_size ; La taille réelle du lot de la tâche en aval (par exemple, classification) est --batch_size . Ensuite, nous faisons des inférences avec le modèle affiné.
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 spécifie le chemin du fichier à prédire. Le fichier doit contenir la colonne text_a. --prediction_path spécifie le chemin du fichier contenant les résultats de la prédiction. Nous devons spécifier explicitement le nombre d'étiquettes par --labels_num . L'ensemble de données ci-dessus est un ensemble de données de classification bidirectionnelle.
Le contenu ci-dessus fournit des méthodes de base d'utilisation de UER-py pour prétraiter, pré-entraîner, affiner et effectuer des inférences. D'autres cas d'utilisation peuvent être trouvés dans le ➡️ quickstart complet ⬅️ . Le guide de démarrage rapide complet contient de nombreux cas d'utilisation, couvrant la plupart des scénarios d'application liés à la pré-formation. Il est recommandé aux utilisateurs de lire le guide de démarrage rapide complet afin d'utiliser le projet de manière raisonnable.
Cette section fournit des liens vers une gamme de ➡️ données de pré-entraînement ⬅️ . UER peut charger directement ces données de pré-entraînement.
Cette section fournit des liens vers une gamme d'➡️ ensembles de données en aval ⬅️. UER peut charger ces ensembles de données directement.
Avec l'aide de l'UER, nous avons pré-entraîné des modèles de différentes propriétés (par exemple des modèles basés sur différents corpus, encodeurs et cibles). Une introduction détaillée des modèles pré-entraînés et leurs liens de téléchargement peuvent être trouvés dans ➡️ modelzoo ⬅️ . Tous les modèles pré-entraînés peuvent être chargés directement par UER.
UER-py est organisé comme suit：
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
Le code est organisé en fonction de composants (par exemple, intégrations, encodeurs). Les utilisateurs peuvent l'utiliser et l'étendre avec peu d'efforts.
Des exemples complets d'utilisation de l'UER peuvent être trouvés dans les ➡️ instructions ⬅️, qui aident les utilisateurs à mettre en œuvre rapidement des modèles de pré-formation tels que BERT, GPT-2, ELMo, T5 et à affiner les modèles pré-entraînés sur une gamme de tâches en aval.
UER-py a été utilisé dans les solutions gagnantes de nombreux concours PNL. Dans cette section, nous fournissons quelques exemples d'utilisation de UER-py pour obtenir des résultats SOTA sur des compétitions PNL, telles que CLUE. Voir ➡️ solutions de concurrence ⬅️ pour des informations plus détaillées.
@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}
}
Pour toute communication relative à ce projet, veuillez contacter Zhe Zhao ([email protected]; [email protected]) ou Yudong Li ([email protected]) ou Cheng Hou ([email protected]) ou Wenhang Shi ([email protected]).
Ce travail est confié à mes mentors d'entreprise Qi Ju , Xuefeng Yang , Haotang Deng et à mes mentors scolaires Tao Liu , Xiaoyong Du .
Nous avons également reçu beaucoup d'aide de Weijie Liu, Lusheng Zhang, Jianwei Cui, Xiayu Li, Weiquan Mao, Xin Zhao, Hui Chen, Jinbin Zhang, Zhiruo Wang, Peng Zhou, Haixiao Liu et Weijian Wu.
