TencentPretrain
1.0.0
Anglais |中文
La pré-formation est devenue un élément essentiel de la technologie de l’IA. TencentPretrain est une boîte à outils pour la pré-formation et le réglage fin des données de différentes modalités (par exemple texte et vision). TencentPretrain se caractérise par une conception modulaire. Il facilite l'utilisation des modèles de pré-formation existants et fournit des interfaces permettant aux utilisateurs de les développer davantage. Avec TencentPretrain, nous construisons un zoo modèle qui contient des modèles pré-entraînés de différentes propriétés. TencentPretrain hérite de la boîte à outils open source UER (https://github.com/dbiir/UER-py/) et l'étend à un cadre de pré-formation multimodal.
TencentPretrain a les fonctionnalités suivantes :
Cette section utilise plusieurs exemples couramment utilisés pour montrer comment utiliser TencentPretrain. 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 sentiments 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 TencentPretrain 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 TencentPretrain pour pré-traiter, pré-entraîner, affiner et faire 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 ⬅️ . TencentPretrain 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 ⬅️. TencentPretrain peut charger ces ensembles de données directement.
Avec l'aide de TencentPretrain, nous avons pré-entraîné des modèles de différentes propriétés (par exemple des modèles basés sur différentes modalités, 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 TencentPretrain.
TencentPretrain est organisé comme suit：
TencentPretrain/
|--tencentpretrain/
| |--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 TencentPretrain 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, CLIP et à affiner les modèles pré-entraînés sur une gamme de tâches en aval.
TencentPretrain a été utilisé dans les solutions gagnantes de nombreux concours. Dans cette section, nous fournissons quelques exemples d'utilisation de TencentPretrain pour obtenir des résultats SOTA sur des compétitions, telles que CLUE. Voir ➡️ solutions de concurrence ⬅️ pour des informations plus détaillées.
@article{zhao2023tencentpretrain,
title={TencentPretrain: A Scalable and Flexible Toolkit for Pre-training Models of Different Modalities},
author={Zhao, Zhe and Li, Yudong and Hou, Cheng and Zhao, Jing and others},
journal={ACL 2023},
pages={217},
year={2023}
}
