electra
1.0.0
Electra est une méthode d'apprentissage de la représentation des langues auto-supervisée. Il peut être utilisé pour pré-entraîner les réseaux de transformateurs en utilisant relativement peu de calcul. Les modèles Electra sont formés pour distinguer les jetons d'entrée "réels" vs des jetons d'entrée "faux" générés par un autre réseau neuronal, similaire au discriminateur d'un GAN. À petite échelle, Electra obtient de solides résultats même lorsqu'il est formé sur un seul GPU. À grande échelle, Electra obtient des résultats de pointe sur l'ensemble de données Squad 2.0.
Pour une description détaillée et des résultats expérimentaux, veuillez vous référer à notre encodeurs de texte ICLR 2020: Pré-formation de texte comme discriminateurs plutôt que générateurs.
Ce référentiel contient du code pour pré-entraîner Electra, y compris de petits modèles Electra sur un seul GPU. Il prend également en charge l'électra de réglage fin sur les tâches en aval, y compris les tâches de classification (par exemple, la colle), les tâches QA (par exemple, l'escouade) et les tâches de marquage de séquence (par exemple, le morceau de texte).
Ce référentiel contient également Code for Electric , une version d'Electra inspirée des modèles basés sur l'énergie. L'électrique fournit une vue plus fondée sur des principes d'Electra en tant que modèle de serrage "d'échantillonnage négatif". Il peut également produire efficacement des scores de pseudo-vraisemblance pour le texte, qui peuvent être utilisés pour recommandant les sorties de systèmes de reconnaissance vocale ou de traduction automatique. Pour plus de détails sur l'électricité, veuillez vous référer aux transformateurs de pré-formation de papier EMNLP 2020 en tant que modèles Cloze basés sur l'énergie.
Nous publions initialement trois modèles pré-formés:
| Modèle | Couches | Taille cachée | Paramètres | Score de colle (Test Set) | Télécharger |
|---|---|---|---|---|---|
| Électra-petit | 12 | 256 | 14m | 77.4 | lien |
| Base électra | 12 | 768 | 110m | 82.7 | lien |
| Électra-grand | 24 | 1024 | 335m | 85.2 | lien |
Les modèles ont été formés sur un texte anglais non couvert. Ils correspondent à Electra-Small ++, Electra-Base ++, Electra-1,75m dans notre papier. Nous espérons publier d'autres modèles, tels que des modèles multilingues, à l'avenir.
Sur la colle, Electra-Large score légèrement mieux que Albert / XLNET, Electra-base score mieux que Bert-Garg et Electra-Small scores légèrement pire que Tinybert (mais n'utilise aucune distillation). Voir la section Résultats attendue ci-dessous pour les numéros de performances détaillés.
Utilisez build_pretraining_dataset.py pour créer un ensemble de données pré-formation à partir d'un vidage de texte brut. Il a les arguments suivants:
--corpus-dir : Un répertoire contenant des fichiers texte bruts à transformer en exemples Electra. Un fichier texte peut contenir plusieurs documents avec des lignes vides les séparant.--vocab-file : fichier définissant le vocabulaire de la pièce.--output-dir : Où rédiger des exemples d'Electra.--max-seq-length : le nombre de jetons par exemple (128 par défaut).--num-processes : si> 1 parallélisez sur plusieurs processus (1 par défaut).--blanks-separate-docs : si les lignes vierges indiquent les limites du document (vrai par défaut).--do-lower-case/--no-lower-case : SI pour abaisser le texte d'entrée (vrai par défaut). Utilisez run_pretraining.py pour pré-entraîner un modèle Electra. Il a les arguments suivants:
--data-dir : Un répertoire où les données de pré-formation, les poids du modèle, etc. sont stockées. Par défaut, la formation charge des exemples de <data-dir>/pretrain_tfrecords et un vocabulaire de <data-dir>/vocab.txt .--model-name : un nom pour le modèle formé. Les poids des modèles seront enregistrés dans <data-dir>/models/<model-name> par défaut.--hparams (facultatif): un dict JSON ou un chemin vers un fichier JSON contenant des hyperparamètres, des chemins de données, etc. Voir configure_pretraining.py pour les hyperparamètres pris en charge. Si la formation est interrompue, relancez le run_pretraining.py avec les mêmes arguments continuera la formation où elle s'était arrêtée.
Vous pouvez continuer la pré-formation des points de contrôle Electra libérés par
--model-name electra_small si vous avez téléchargé des poids sur $DATA_DIR/electra_small ).num_train_steps par (par exemple) ajoutant "num_train_steps": 4010000 aux --hparams . Cela continuera à former le petit modèle pour 10000 étapes supplémentaires (il a déjà été formé pour 4e6 étapes).learning_rate sur 2E-4 * (4E6 + 10000) / 10000."generator_hidden_size": 1.0 dans les hparams car nous n'avons pas utilisé de petit générateur pour ce modèle. Ces instructions pré-entraînent un petit modèle Electra (12 couches, 256 taille cachée). Malheureusement, les données que nous avons utilisées dans le document ne sont pas accessibles au public, nous utiliserons donc l'OpenWebTextCorpus publié par Aaron Gokaslan et Vanya Cohen à la place. Le modèle entièrement formé (~ 4 jours sur un GPU V100) devrait fonctionner à peu près entre GPT et Bert-base en termes de performances de colle. Par défaut, le modèle est formé sur des séquences de longueur-128, il ne convient donc pas pour fonctionner sur la réponse aux questions. Voir la section "Résultats attendus" ci-dessous pour plus de détails sur les performances du modèle.
$DATA_DIR/vocab.txt . Nos modèles Electra ont tous utilisé exactement le même vocabulaire que l'anglais Unased Bert, que vous pouvez télécharger ici.tar xf openwebtext.tar.xz ). Placez-le dans $DATA_DIR/openwebtext .python3 build_openwebtext_pretraining_dataset.py --data-dir $DATA_DIR --num-processes 5 . Il prépare / tokenise les exemples de données et de sortie en tant que fichiers tfrecord sous $DATA_DIR/pretrain_tfrecords . Les tfrecords nécessitent environ 30 g d'espace disque. Exécutez python3 run_pretraining.py --data-dir $DATA_DIR --model-name electra_small_owt pour former un petit modèle Electra pour 1 million d'étapes sur les données. Cela prend un peu plus de 4 jours sur un GPU Tesla V100. Cependant, le modèle devrait obtenir des résultats décents après 200 000 étapes (10 heures de formation sur le GPU V100).
Pour personnaliser la formation, ajoutez --hparams '{"hparam1": value1, "hparam2": value2, ...}' à la commande RUN. --hparams peut également être un chemin vers un fichier .json contenant les hyperparamètres. Quelques options particulièrement utiles:
"debug": true entraîne un minuscule modèle Electra pour quelques étapes."model_size": one of "small", "base", or "large" : détermine la taille du modèle"electra_objective": false entraîne un modèle avec une modélisation du langage masqué au lieu de remplacer la détection des jetons (essentiellement Bert par un masquage dynamique et aucune prédiction de phase suivante)."num_train_steps": n contrôle combien de temps le modèle est pré-formé."pretrain_tfrecords": <paths> détermine où se trouve les données de pré-formation. Remarque Vous devez spécifier les fichiers spécifiques et non seulement le répertoire (par exemple, <data-dir>/pretrain_tf_records/pretrain_data.tfrecord* )"vocab_file": <path> et "vocab_size": n peut être utilisé pour définir un vocabulaire personnalisé."learning_rate": lr, "train_batch_size": n , etc. peut être utilisé pour changer les hyperparamètres de formation"model_hparam_overrides": {"hidden_size": n, "num_hidden_layers": m} , etc. peut être utilisé pour modifier les hyperparamètres pour le transformateur sous-jacent (l'indicateur "model_size" définit les valeurs par défaut). Voir configure_pretraining.py pour l'ensemble complet d'hyperparamètres pris en charge.
Pour évaluer le modèle sur une tâche en aval, consultez les instructions de financement ci-dessous. Pour évaluer le générateur / discriminateur sur les données OpenWebText Run python3 run_pretraining.py --data-dir $DATA_DIR --model-name electra_small_owt --hparams '{"do_train": false, "do_eval": true}' . Cela imprimera les mesures d'évaluation telles que la précision du générateur et du discriminatrice, et rédigea également les mesures sur data-dir/model-name/results .
Utilisez run_finetuning.py pour affiner et évaluer un modèle Electra sur une tâche NLP en aval. Il attend trois arguments:
--data-dir : un répertoire où les données, les poids du modèle, etc. sont stockées. Par défaut, le script charge les données Finetuning de <data-dir>/finetuning_data/<task-name> et un vocabulaire de <data-dir>/vocab.txt .--model-name : Un nom du modèle pré-formé: les poids pré-formés doivent exister dans data-dir/models/model-name .--hparams : un dict JSON contenant des hyperparamètres de modèle, des chemins de données, etc. (par exemple, --hparams '{"task_names": ["rte"], "model_size": "base", "learning_rate": 1e-4, ...}' ). Voir configure_pretraining.py pour les hyperparamètres pris en charge. Au lieu d'un dict, cela peut également être un chemin vers un fichier .json contenant les hyperparamètres. Vous devez spécifier les "task_names" et "model_size" (voir les exemples ci-dessous). Les mesures d'évaluation seront enregistrées dans data-dir/model-name/results et les poids du modèle seront enregistrés dans data-dir/model-name/finetuning_models par défaut. L'évaluation est effectuée sur l'ensemble de développement par défaut. Pour personnaliser la formation, ajoutez --hparams '{"hparam1": value1, "hparam2": value2, ...}' à la commande RUN. Quelques options particulièrement utiles:
"debug": true Fine-Tunes un minuscule modèle Electra pour quelques étapes."task_names": ["task_name"] : spécifie les tâches sur lesquelles se former. Une liste parce que la base de code prend en charge nominale l'apprentissage multi-tâches (bien qu'il soit averti que cela n'a pas été testé en profondeur)."model_size": one of "small", "base", or "large" : détermine la taille du modèle; Vous devez le régler sur la même taille que le modèle pré-formé."do_train" and "do_eval" : former et / ou évaluer un modèle (les deux sont définis sur true par défaut). Pour utiliser "do_eval": true avec "do_train": false , vous devez spécifier l' init_checkpoint , par exemple, python3 run_finetuning.py --data-dir $DATA_DIR --model-name electra_base --hparams '{"model_size": "base", "task_names": ["mnli"], "do_train": false, "do_eval": true, "init_checkpoint": "<data-dir>/models/electra_base/finetuning_models/mnli_model_1"}'"num_trials": n : si> 1, fait plusieurs fonctions de réglage / évaluation avec différentes graines aléatoires."learning_rate": lr, "train_batch_size": n , etc. peut être utilisé pour changer les hyperparamètres de formation."model_hparam_overrides": {"hidden_size": n, "num_hidden_layers": m} , etc. peut être utilisé pour modifier les hyperparamètres pour le transformateur sous-jacent (l'indicateur "model_size" définit les valeurs par défaut). Obtenez un modèle Electra pré-formé soit en formant le vôtre (voir les instructions de pré-formation ci-dessus), soit en téléchargeant les poids électriques de version et en les décomptant sous $DATA_DIR/models (par exemple, vous devriez avoir un répertoire $DATA_DIR/models/electra_large si vous utilisez le grand modèle).
Téléchargez les données de colle en exécutant ce script. Configurez les données en exécutant mv CoLA cola && mv MNLI mnli && mv MRPC mrpc && mv QNLI qnli && mv QQP qqp && mv RTE rte && mv SST-2 sst && mv STS-B sts && mv diagnostic/diagnostic.tsv mnli && mkdir -p $DATA_DIR/finetuning_data && mv * $DATA_DIR/finetuning_data .
Ensuite, exécutez run_finetuning.py . Par exemple, pour affiner la base électrique sur MNLI
python3 run_finetuning.py --data-dir $DATA_DIR --model-name electra_base --hparams '{"model_size": "base", "task_names": ["mnli"]}'
Ou affiner un petit modèle pré-formé en utilisant les instructions ci-dessus sur COLA.
python3 run_finetuning.py --data-dir $DATA_DIR --model-name electra_small_owt --hparams '{"model_size": "small", "task_names": ["cola"]}'
Le code prend en charge Squad 1.1 et 2.0, ainsi que des ensembles de données dans la tâche partagée MRQA 2019
$DATA_DIR/finetuning_data/squadv1/(train|dev).json$DATA_DIR/finetuning_data/squad/(train|dev).json$DATA_DIR/finetuning_data/(newsqa|naturalqs|triviaqa|searchqa)/(train|dev).jsonl .Puis exécutez (par exemple)
python3 run_finetuning.py --data-dir $DATA_DIR --model-name electra_base --hparams '{"model_size": "base", "task_names": ["squad"]}'
Ce référentiel utilise le code d'évaluation officiel publié par les auteurs de Squad et la tâche partagée MRQA pour calculer les mesures
Téléchargez l'ensemble de données CONLL-2000 Text Chunking à partir d'ici et mettez-les sous $DATA_DIR/finetuning_data/chunk/(train|dev).txt . Puis courez
python3 run_finetuning.py --data-dir $DATA_DIR --model-name electra_base --hparams '{"model_size": "base", "task_names": ["chunk"]}'
La façon la plus simple d'exécuter une nouvelle tâche consiste à implémenter un nouveau finetune.task.Task , à l'ajouter à finetune.task_builder.py , puis à utiliser run_finetuning.py comme d'habitude. Pour la classification / QA / étiquetage de séquence, vous pouvez hériter d'un finetune.classification.classification_tasks.ClassificationTask , finetune.qa.qa_tasks.QATask , ou finetune.tagging.tagging_tasks.TaggingTask . Pour les données de prétraitement, nous utilisons le même tokenizer que Bert.
Voici les résultats attendus pour Electra sur diverses tâches (ensemble de tests pour le groupe, Dev Set pour les autres tâches). Notez que la variance dans le réglage fin peut être assez importante, donc pour certaines tâches, vous pouvez voir de grandes fluctuations dans les scores lors de la fin du même point de contrôle. Les scores ci-dessous montrent des performances médianes sur un grand nombre de graines aléatoires. Electra-Small / Base / Large est nos modèles publiés. Electra-Small-Owt est le modèle formé OpenWebText d'en haut (il fonctionne un peu pire que l'Electra-Small en raison de la formation pendant moins de temps et sur un ensemble de données plus petit).
| Cola | SST | MRPC | STS | QQP | MNLI | QNLI | Rte | Escouade 1.1 | Escouade 2.0 | Se déchaîner | |
|---|---|---|---|---|---|---|---|---|---|---|---|
| Métrique | MCC | Accrocheur | Accrocheur | Lancier | Accrocheur | Accrocheur | Accrocheur | Accrocheur | Em | Em | F1 |
| Électra-grand | 69.1 | 96.9 | 90.8 | 92.6 | 92.4 | 90.9 | 95.0 | 88.0 | 89.7 | 88.1 | 97.2 |
| Base électra | 67.7 | 95.1 | 89.5 | 91.2 | 91.5 | 88.8 | 93.2 | 82.7 | 86.8 | 80.5 | 97.1 |
| Électra-petit | 57.0 | 91.2 | 88.0 | 87.5 | 89.0 | 81.3 | 88.4 | 66.7 | 75.8 | 70.1 | 96.5 |
| Electra-Small-Owt | 56.8 | 88.3 | 87.4 | 86.8 | 88.3 | 78.9 | 87.9 | 68.5 | - | - | - |
Voir ici pour les pertes / courbes d'entraînement des modèles pendant la pré-formation.
Pour former l'électricité, utilisez le même script et commande de pré-formation que Electra. Passez "electra_objective": false et "electric_objective": true aux hyperparamètres. Nous prévoyons de publier bientôt des modèles électriques pré-formés!
Si vous utilisez ce code pour votre publication, veuillez citer le papier d'origine:
@inproceedings{clark2020electra,
title = {{ELECTRA}: Pre-training Text Encoders as Discriminators Rather Than Generators},
author = {Kevin Clark and Minh-Thang Luong and Quoc V. Le and Christopher D. Manning},
booktitle = {ICLR},
year = {2020},
url = {https://openreview.net/pdf?id=r1xMH1BtvB}
}
Si vous utilisez le code pour l'électricité, veuillez citer le papier électrique:
@inproceedings{clark2020electric,
title = {Pre-Training Transformers as Energy-Based Cloze Models},
author = {Kevin Clark and Minh-Thang Luong and Quoc V. Le and Christopher D. Manning},
booktitle = {EMNLP},
year = {2020},
url = {https://www.aclweb.org/anthology/2020.emnlp-main.20.pdf}
}
Pour obtenir de l'aide ou des problèmes à l'aide d'Electra, veuillez soumettre un problème GitHub.
Pour la communication personnelle liée à Electra, veuillez contacter Kevin Clark ( [email protected] ).
