xlnet_sequence_tagging
1.0.0
Nous développons ce projet pour le marquage des tâches que NLPer se réunit toujours.
Utilisez XLNET pour suivre les tâches
Alarme, ces codes ne sont pas encore terminés. Soyez prudent à utiliser.
Par exemple, exécutez les Scipts en utilisant:
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://uversaldependces.org/
Vous pouvez utiliser "Rechercher ./ -name * test / dev / train.conll" pour trouver tous les fichiers conll et utiliser xargs pour les copier sur DATA_DIR
https://github.com/yuchenlin/ontonotes-5.0-ner-bio
Copiez simplement les fichiers anglais sur data_dir à l'aide du fichier de script python: onotonotes_conll_copyfile.py (vous devrez peut-être modifier les chemins)
Les PR sont les bienvenus! Veuillez aider avec le projet de développement pour améliorer notre puissance NLP!
XLNET est une nouvelle méthode d'apprentissage de représentation de langue non supervisée basée sur un nouvel objectif de modélisation de la langue de permutation généralisée. De plus, XLNET utilise Transformer-XL comme modèle de squelette, présentant d'excellentes performances pour les tâches linguistiques impliquant un contexte long. Dans l'ensemble, XLNET obtient des résultats ultramodernes (SOTA) sur diverses tâches de langage en aval, notamment la réponse aux questions, l'inférence du langage naturel, l'analyse des sentiments et le classement des documents.
Pour une description détaillée des détails techniques et des résultats expérimentaux, veuillez vous référer à notre article:
XLNET: pré-entraînement autorégressif généralisé pour la compréhension du langage
Zhilin Yang *, Zihang Dai *, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, Quoc V.
(*: Contribution égale)
Preprint 2019
Au 19 juin 2019, XLNET surpasse Bert sur 20 tâches et obtient des résultats de pointe sur 18 tâches. Vous trouverez ci-dessous une comparaison entre XLNET-GARD et BERT-GARD, qui ont des tailles de modèle similaires:
| Modèle | Précision de la course | Squad1.1 em | Squad2.0 em |
|---|---|---|---|
| Bert-grand | 72.0 | 84.1 | 78,98 |
| Base xlnet | 80.18 | ||
| Xlnet-grand | 81.75 | 88,95 | 86.12 |
Nous utilisons les résultats de Squad Dev dans le tableau pour exclure d'autres facteurs tels que l'utilisation de données de formation supplémentaires ou d'autres techniques d'augmentation des données. Voir Squad Leadboard pour les numéros de test.
| Modèle | Imdb | Yelp-2 | Yelp-5 | Dbpedia | Amazon-2 | Amazon-5 |
|---|---|---|---|---|---|---|
| Bert-grand | 4.51 | 1.89 | 29.32 | 0,64 | 2.63 | 34.17 |
| Xlnet-grand | 3.79 | 1.55 | 27.80 | 0,62 | 2.40 | 32.26 |
Les nombres ci-dessus sont des taux d'erreur.
| Modèle | MNLI | QNLI | QQP | Rte | SST-2 | MRPC | Cola | STS-B |
|---|---|---|---|---|---|---|---|---|
| Bert-grand | 86.6 | 92.3 | 91.3 | 70.4 | 93.2 | 88.0 | 60.6 | 90.0 |
| Base xlnet | 86.8 | 91.7 | 91.4 | 74.0 | 94.7 | 88.2 | 60.2 | 89.5 |
| Xlnet-grand | 89.8 | 93.9 | 91.8 | 83.8 | 95.6 | 89.2 | 63.6 | 91.8 |
Nous utilisons des résultats de développement d'une seule tâche dans le tableau pour exclure d'autres facteurs tels que l'apprentissage multi-tâches ou l'utilisation d'ensembles.
À partir du 16 juillet 2019, les modèles suivants ont été mis à disposition:
XLNet-Large, Cased : 24 couches, 1024 coiffées, 16 têtesXLNet-Base, Cased : 12 couches, 768, 12-têtes. Ce modèle est formé sur des données complètes (différentes de celles du papier).Nous ne publions que des modèles BASED pour l'instant car sur les tâches que nous considérons, nous avons trouvé: (1) pour le réglage de base, les modèles en tube et non basés ont des performances similaires; (2) Pour le réglage grand, les modèles en tube sont un peu meilleurs dans certaines tâches.
Chaque fichier .zip contient trois éléments:
xlnet_model.ckpt ) contenant les poids pré-formés (qui sont en fait 3 fichiers).spiece.model ) utilisé pour (DE) tokenisation.xlnet_config.json ) qui spécifie les hyperparamètres du modèle.Nous prévoyons également de libérer en continu davantage de modèles pré-entraînés dans différents contextes, notamment:
Pour recevoir des notifications sur les mises à jour, les annonces et les nouvelles versions, nous vous recommandons de vous abonner au XLNET sur les groupes Google.
Au 19 juin 2019, cette base de code a été testée avec TensorFlow 1.13.1 sous Python2.
XLNet-Large dans le papier en utilisant des GPU avec 12 Go - 16 Go de RAM, car un GPU de 16 Go est capable de maintenir une seule séquence avec une longueur 512 pour XLNet-Large . Par conséquent, un grand nombre (allant de 32 à 128, égal à batch_size ) des GPU est nécessaire pour reproduire de nombreux résultats dans le papier. Compte tenu du problème de mémoire mentionné ci-dessus, en utilisant les scripts Finetuning par défaut ( run_classifier.py et run_squad.py ), nous avons comparé la taille maximale du lot sur un seul GPU de 16 Go avec TensorFlow 1.13.1 :
| Système | Longueur de seq | Taille du lot maximum |
|---|---|---|
XLNet-Base | 64 | 120 |
| ... | 128 | 56 |
| ... | 256 | 24 |
| ... | 512 | 8 |
XLNet-Large | 64 | 16 |
| ... | 128 | 8 |
| ... | 256 | 2 |
| ... | 512 | 1 |
Dans la plupart des cas, il est possible de réduire la taille du lot train_batch_size ou la longueur maximale de séquence max_seq_length pour s'adapter au matériel donné. La diminution des performances dépend de la tâche et des ressources disponibles.
Le code utilisé pour effectuer des finetuning de classification / régression est dans run_classifier.py . Il contient également des exemples de classification standard à un document, de régression à un document et de classification des paires de documents. Ici, nous fournissons deux exemples en béton de la façon dont run_classifier.py peut être utilisé.
À partir de maintenant, nous supposons que XLNET-GARD et XLNET-Base ont été téléchargés respectivement sur $LARGE_DIR et $BASE_DIR .
Téléchargez les données de colle en exécutant ce script et déballer dans un répertoire $GLUE_DIR .
Effectuer des finetuning multi-GPU (4 GPU V100) avec XLNET-GARD en fonctionnant
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=TrueÉvaluer les résultats de la finetunage avec un seul GPU par
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+ "Notes :
num_core_per_host désigne le nombre de GPU à utiliser.train_batch_size fait référence à la taille du lot Per-GPU.eval_all_ckpt permet d'évaluer tous les points de contrôle enregistrés (la fréquence de sauvegarde est contrôlée par save_steps ) après les finitions de formation et choisissez le meilleur modèle en fonction des performances de développement.data_dir et output_dir se réfèrent aux répertoires des "données brutes" et "TFRecords prétraités" respectivement, tandis que model_dir est le répertoire de travail pour enregistrer les points de contrôle et les événements TensorFlow. model_dir doit être défini en tant que dossier séparé sur init_checkpoint .--train_batch_size=32 et --num_core_per_host=1 , ainsi que les modifications dans init_checkpoint et model_config_path .train_batch_size et augmenter num_core_per_host pour utiliser le même paramètre de formation.Télécharger et déballer l'ensemble de données IMDB en exécutant
wget http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz
tar zxvf aclImdb_v1.tar.gzLancez une instance Google Cloud TPU V3-8 (voir le tutoriel Google Cloud TPU pour configurer les TPU cloud).
Configurez votre chemin de baquet Google Storage $GS_ROOT et déplacez l'ensemble de données IMDB et le point de contrôle pré-traqué dans votre stockage Google.
Effectuer TPU Finetuning avec XLNet-Large en fonctionnant
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+ "Notes :
data_dir et spiece_model_file utilisent tous deux un chemin local plutôt qu'un chemin de stockage Google. La raison en est que le prétraitement des données est effectivement effectué localement. Par conséquent, l'utilisation de chemins locaux conduit à une vitesse de prétraitement plus rapide. Le code de l'ensemble de données d'escouade est inclus dans run_squad.py .
Pour exécuter le code:
(1) Téléchargez l'ensemble de données Squad2.0 dans $SQUAD_DIR par:
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) Effectuer le prétraitement des données à l'aide des scripts/prepro_squad.sh .
Cela prendra un certain temps afin de cartographier avec précision les positions des caractères (données brutes) aux positions des pièces de phrase (utilisées pour la formation).
Pour un prétraitement parallèle plus rapide, veuillez consulter les drapeaux --num_proc et --proc_id dans run_squad.py .
(3) Effectuer une formation et une évaluation.
Pour les meilleures performances, XLNET-GARD utilise la longueur de séquence 512 et la taille du lot 48 pour la formation.
En conséquence, la reproduction du meilleur résultat avec les GPU est assez difficile.
Pour une formation avec un TPU v3-8, on peut simplement exécuter les scripts/tpu_squad_large.sh après que le stockage TPU et Google ont été configurés.
run_squad.py effectuera automatiquement la recherche de seuil sur le jeu de développement de Squad et sortira le score. Avec scripts/tpu_squad_large.sh , le score F1 attendu devrait être d'environ 88,6 (médiane de nos multiples séries).
Alternativement, on peut utiliser la base XLNET avec des GPU (par exemple trois V100). Un ensemble d'hyper-paramètres raisonnables peut être trouvé dans les scripts/gpu_squad_base.sh .
Le code de la course de tâches de compréhension en lecture est inclus dans run_race.py .
Pour exécuter le code:
(1) Téléchargez l'ensemble de données de course sur le site officiel et déballer les données brutes à $RACE_DIR .
(2) Effectuer une formation et une évaluation:
script/tpu_race_large_bsz32.sh pour ce paramètre.script/tpu_race_large_bsz8.sh ).Un exemple d'utilisation de Google Colab avec des GPU a été fourni. Notez que puisque le matériel est limité dans l'exemple, les résultats sont pires que les meilleurs que nous pouvons obtenir. Il sert principalement d'exemple et doit être modifié en conséquence pour maximiser les performances.
Pour la finetuning, il est probable que vous pourrez modifier des fichiers existants tels que run_classifier.py , run_squad.py et run_race.py pour votre tâche à portée de main. Cependant, nous fournissons également une abstraction de XLNET pour permettre une utilisation plus flexible. Vous trouverez ci-dessous un exemple:
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`Vous trouverez ci-dessous un exemple de tokenisation dans 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 ) Lorsque FLAGS.spiece_model_file est le fichier de modèle de phrase dans le même zip que le modèle pré-entraîné, FLAGS.uncased est un bool indiquant s'il faut se dérouler.
Reportez-vous à train.py pour pré-formation sur TPUS et train_gpu.py pour pré-formation sur les GPU. Nous devons d'abord prétraiter les données de texte en tfrecords.
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 Lorsque input_glob définit tous les fichiers de texte d'entrée, save_dir est le répertoire de sortie pour tfrecords et sp_path est un modèle de pièce de phrase. Voici notre script pour entraîner le modèle de la pièce de phrase
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 Des symboles spéciaux sont utilisés, y compris control_symbols et user_defined_symbols . Nous utilisons <eop> et <eod> pour désigner respectivement la fin du paragraphe et de la fin du document.
Les fichiers texte d'entrée sur data_utils.py doivent utiliser le format suivant:
<eop> peut être insérée à la fin de certaines lignes (sans aucun espace) pour indiquer que la phrase correspondante met fin à un paragraphe.Par exemple, le fichier d'entrée de texte pourrait être:
This is the first sentence.
This is the second sentence and also the end of the paragraph.<eop>
Another paragraph.
Another document starts here.
Après le prétraitement, nous sommes prêts à prénainler un XLNET. Vous trouverez ci-dessous les hyperparamètres utilisés pour la pré-formation de XLNET-GARD:
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=85où nous énumérons uniquement les drapeaux les plus importants et les autres drapeaux pourraient être ajustés en fonction de cas d'utilisation spécifiques.
