electra
1.0.0
Electra es un método para el aprendizaje de representación del lenguaje auto-supervisado. Se puede usar para pre-entrenado redes de transformadores utilizando relativamente poco cómputo. Los modelos Electra están entrenados para distinguir los tokens de entrada "reales" frente a los tokens de entrada "falsos" generados por otra red neuronal, similar al discriminador de un GaN. A pequeña escala, Electra logra resultados fuertes incluso cuando se entrenan en una sola GPU. A gran escala, Electra logra resultados de última generación en el conjunto de datos Squad 2.0.
Para obtener una descripción detallada y resultados experimentales, consulte nuestro electra de papel ICLR 2020: codificadores de texto previos a la capacitación como discriminadores en lugar de generadores.
Este repositorio contiene código previo a los electro, incluidos los modelos de electra pequeños en una sola GPU. También es compatible con Electra ajustado en las tareas aguas abajo, incluidas las tareas de clasificación (p. Ej., Glue), tareas de control de calidad (p. Ej.
Este repositorio también contiene código para Electric , una versión de Electra inspirada en modelos basados en energía. Electric proporciona una vista más principalmente de Electra como un modelo de cloze de "muestreo negativo". También puede producir eficientemente los puntajes de pseudo probabilidad para el texto, que pueden usarse para volver a clasificar los resultados de los sistemas de reconocimiento de voz o traducción automática. Para obtener detalles sobre electricidad, consulte los transformadores de pre-entrenamiento de papel EMNLP 2020 como modelos de cloze basados en energía.
Inicialmente estamos liberando tres modelos previamente capacitados:
| Modelo | Capas | Tamaño oculto | Parámetros | Puntuación de pegamento (conjunto de pruebas) | Descargar |
|---|---|---|---|---|---|
| Electro-pequeña | 12 | 256 | 14m | 77.4 | enlace |
| Electra-base | 12 | 768 | 110m | 82.7 | enlace |
| Electra-grande | 24 | 1024 | 335m | 85.2 | enlace |
Los modelos fueron entrenados en texto en inglés no basado. Corresponden a Electra-Small ++, Electra-Base ++, Electra-1.75m en nuestro documento. Esperamos lanzar otros modelos, como modelos multilingües, en el futuro.
En el pegamento, los puntajes de electricidad ligeramente mejor que Albert/XLNet, las puntuaciones electra-base mejores que Bert-Large y los puntajes de electricidad ligeramente peor que Tinybert (pero no usa destilación). Consulte la sección de resultados esperado a continuación para obtener números de rendimiento detallados.
Use build_pretraining_dataset.py para crear un conjunto de datos de pre-entrenamiento a partir de un volcado de texto sin procesar. Tiene los siguientes argumentos:
--corpus-dir : un directorio que contiene archivos de texto sin procesar para convertirse en ejemplos de electra. Un archivo de texto puede contener múltiples documentos con líneas vacías que los separan.--vocab-file : Archivo Definición del vocabulario de la obra de palabras.--output-dir : dónde escribir ejemplos de electra.--max-seq-length : el número de tokens por ejemplo (128 por defecto).--num-processes : si> 1 paralela en múltiples procesos (1 por defecto).--blanks-separate-docs : si las líneas en blanco indican los límites del documento (verdadero de forma predeterminada).--do-lower-case/--no-lower-case : si debe a minúscula el texto de entrada (verdadero de forma predeterminada). Use run_pretraining.py para pre-entrenamiento de un modelo Electra. Tiene los siguientes argumentos:
--data-dir : un directorio donde se almacenan datos de pre-entrenamiento, pesos del modelo, etc. Por defecto, el entrenamiento carga ejemplos de <data-dir>/pretrain_tfrecords y un vocabulario de <data-dir>/vocab.txt .--model-name : un nombre para el modelo que está entrenado. Los pesos del modelo se guardarán en <data-dir>/models/<model-name> Por defecto.--hparams (opcional): un JSON dict o ruta a un archivo JSON que contiene hiperparámetros del modelo, rutas de datos, etc. Consulte configure_pretraining.py para los hiperparámetros compatibles. Si se detiene el entrenamiento, volver a correr el run_pretraining.py con los mismos argumentos continuará con el entrenamiento donde lo dejó.
Puede continuar previamente la capacitación desde los puntos de control de Electra liberados por
--model-name electra_small si descargó pesos a $DATA_DIR/electra_small ).num_train_steps por (por ejemplo) agregando "num_train_steps": 4010000 al --hparams . Esto continuará entrenando al modelo pequeño para 10000 pasos más (ya ha sido entrenado para 4E6 pasos).learning_rate en 2E-4 * (4E6 + 10000) / 10000."generator_hidden_size": 1.0 en los hparams porque no usamos un generador pequeño para ese modelo. Estas instrucciones pre-entrenan un modelo de electra pequeño (12 capas, 256 tamaño oculto). Desafortunadamente, los datos que utilizamos en el documento no están disponibles públicamente, por lo que utilizaremos el OpenWebTextCorpus lanzado por Aaron Gokaslan y Vanya Cohen. El modelo totalmente capacitado (~ 4 días en una GPU V100) debe funcionar aproximadamente entre GPT y Bert-Base en términos de rendimiento del pegamento. Por defecto, el modelo está entrenado en secuencias de longitud-128, por lo que no es adecuado para ejecutar la respuesta a las preguntas. Consulte la sección "Resultados esperados" a continuación para obtener más detalles sobre el rendimiento del modelo.
$DATA_DIR/vocab.txt . Nuestros modelos Electra usaron exactamente el mismo vocabulario que el Bert sin base en inglés, que puede descargar aquí.tar xf openwebtext.tar.xz ). Colóquelo en $DATA_DIR/openwebtext .python3 build_openwebtext_pretraining_dataset.py --data-dir $DATA_DIR --num-processes 5 . Preprocesas/toca los datos y emite ejemplos como archivos TFRecord en $DATA_DIR/pretrain_tfrecords . Los TFRecords requieren aproximadamente 30 g de espacio en disco. Ejecute python3 run_pretraining.py --data-dir $DATA_DIR --model-name electra_small_owt para entrenar un pequeño modelo de electra para 1 millón de pasos en los datos. Esto lleva un poco más de 4 días en una GPU Tesla V100. Sin embargo, el modelo debe lograr resultados decentes después de 200K pasos (10 horas de entrenamiento en la GPU V100).
Para personalizar la capacitación, agregue --hparams '{"hparam1": value1, "hparam2": value2, ...}' al comando Ejecutar. --hparams también puede ser una ruta a un archivo .json que contiene los hiperparámetros. Algunas opciones particularmente útiles:
"debug": true entrena un pequeño modelo Electra para algunos pasos."model_size": one of "small", "base", or "large" : determina el tamaño del modelo"electra_objective": false entrena un modelo con modelado de lenguaje enmascarado en lugar de detección de token reemplazada (esencialmente Bert con enmascaramiento dinámico y sin predicción de la oración siguiente)."num_train_steps": n controla cuánto tiempo se entrena el modelo."pretrain_tfrecords": <paths> determina dónde se encuentran los datos de pre-entrenamiento. Tenga en cuenta que debe especificar los archivos específicos no solo el directorio (por ejemplo, <data-dir>/pretrain_tf_records/pretrain_data.tfrecord* )"vocab_file": <path> y "vocab_size": n se puede usar para establecer un vocabulario de obra de palabras personalizado."learning_rate": lr, "train_batch_size": n , etc. se puede usar para cambiar los hiperparámetros de entrenamiento"model_hparam_overrides": {"hidden_size": n, "num_hidden_layers": m} , etc. se puede usar para cambiar los hiperparámetros para el transformador subyacente (el indicador "model_size" establece los valores predeterminados). Consulte configure_pretraining.py para el conjunto completo de hiperparámetros compatibles.
Para evaluar el modelo en una tarea aguas abajo, consulte las instrucciones de Finetuning a continuación. Para evaluar el generador/discriminador en OpenWebText Data run python3 run_pretraining.py --data-dir $DATA_DIR --model-name electra_small_owt --hparams '{"do_train": false, "do_eval": true}' . Esto imprimirá métricas de evaluación, como la precisión del generador y discriminador, y también escribirá las métricas a data-dir/model-name/results .
Use run_finetuning.py para ajustar y evaluar un modelo de electra en una tarea NLP aguas abajo. Espera tres argumentos:
--data-dir : un directorio donde se almacenan datos, pesos del modelo, etc. De manera predeterminada, el script carga datos Finetuning de <data-dir>/finetuning_data/<task-name> y un vocabulario de <data-dir>/vocab.txt .--model-name : un nombre del modelo previamente capacitado: los pesos previamente capacitados deben existir en data-dir/models/model-name .--hparams : un JSON dict que contiene hiperparámetros del modelo, rutas de datos, etc. (por ejemplo, --hparams '{"task_names": ["rte"], "model_size": "base", "learning_rate": 1e-4, ...}' ). Consulte configure_pretraining.py para los hiperparámetros compatibles. En lugar de un dict, esto también puede ser una ruta a un archivo .json que contiene los hiperparámetros. Debe especificar el "task_names" y "model_size" (ver ejemplos a continuación). Las métricas de evaluación se guardarán en data-dir/model-name/results y los pesos del modelo se guardarán en data-dir/model-name/finetuning_models de forma predeterminada. La evaluación se realiza en el conjunto de desarrollo por defecto. Para personalizar la capacitación, agregue --hparams '{"hparam1": value1, "hparam2": value2, ...}' al comando Ejecutar. Algunas opciones particularmente útiles:
"debug": true ajuste un modelo de electra para algunos pasos."task_names": ["task_name"] : especifica las tareas para entrenar. Una lista porque la base de código nominalmente admite el aprendizaje de tareas múltiples (aunque se advierta que esto no se ha probado a fondo)."model_size": one of "small", "base", or "large" : determina el tamaño del modelo; Debe establecer esto al mismo tamaño que el modelo previamente capacitado."do_train" and "do_eval" : entrenar y/o evaluar un modelo (ambos están configurados en verdadero de forma predeterminada). Para usar "do_eval": true con "do_train": false , debe especificar init_checkpoint , por ejemplo, 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, realiza múltiples ejecuciones/evaluación con diferentes semillas aleatorias."learning_rate": lr, "train_batch_size": n , etc. se puede usar para cambiar los hiperparámetros de entrenamiento."model_hparam_overrides": {"hidden_size": n, "num_hidden_layers": m} , etc. se puede usar para cambiar los hiperparámetros para el transformador subyacente (el indicador "model_size" establece los valores predeterminados). Obtenga un modelo Electra previamente capacitado, ya sea entrenando el suyo (consulte las instrucciones de pre-entrenamiento arriba) o descargando los pesos de electra de liberación y descomponiéndolos en $DATA_DIR/models (por ejemplo, debe tener un directorio $DATA_DIR/models/electra_large si está utilizando el modelo grande).
Descargue los datos de pegamento ejecutando este script. Configure los datos ejecutando 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 .
Luego ejecute run_finetuning.py . Por ejemplo, para ajustar la base de electra en MNLI
python3 run_finetuning.py --data-dir $DATA_DIR --model-name electra_base --hparams '{"model_size": "base", "task_names": ["mnli"]}'
O ajustar un modelo pequeño previamente capacitado utilizando las instrucciones anteriores en COLA.
python3 run_finetuning.py --data-dir $DATA_DIR --model-name electra_small_owt --hparams '{"model_size": "small", "task_names": ["cola"]}'
El código admite Squad 1.1 y 2.0, así como conjuntos de datos en la tarea compartida de 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 .Luego ejecute (por ejemplo)
python3 run_finetuning.py --data-dir $DATA_DIR --model-name electra_base --hparams '{"model_size": "base", "task_names": ["squad"]}'
Este repositorio utiliza el código de evaluación oficial publicado por los autores del escuadrón y la tarea compartida de MRQA para calcular métricas
Descargue el conjunto de datos de folleto de texto de Conll-2000 desde aquí y colóquelo en $DATA_DIR/finetuning_data/chunk/(train|dev).txt . Luego corre
python3 run_finetuning.py --data-dir $DATA_DIR --model-name electra_base --hparams '{"model_size": "base", "task_names": ["chunk"]}'
La forma más fácil de ejecutar en una nueva tarea es implementar una nueva finetune.task.Task , agrégala a finetune.task_builder.py y luego use run_finetuning.py como normal. Para el etiquetado de clasificación/qa/secuencia, puede heredar de un finetune.classification.classification_tasks.ClassificationTask , finetune.qa.qa_tasks.QATask o finetune.tagging.tagging_tasks.TaggingTask . Para los datos de preprocesamiento, utilizamos el mismo tokenizer que Bert.
Aquí hay resultados esperados para ElectRA en varias tareas (prueba establecida para fragmentos, desarrollo de desarrollo para las otras tareas). Tenga en cuenta que la varianza en el ajuste puede ser bastante grande, por lo que para algunas tareas puede ver grandes fluctuaciones en los puntajes al ajustar desde el mismo punto de control varias veces. Los puntajes a continuación muestran un rendimiento medio en una gran cantidad de semillas aleatorias. Electra-Small/Base/Large son nuestros modelos liberados. Electra-Small-Owt es el modelo aporto-entrenado de OpenWebText desde arriba (funciona un poco peor que Electra-Small debido a que está entrenado por menos tiempo y en un conjunto de datos más pequeño).
| Reajuste salarial | SST | MRPC | Sts | QQP | Mnli | Qnli | RTE | Escuadrón 1.1 | Escuadrón 2.0 | Fragmento | |
|---|---|---|---|---|---|---|---|---|---|---|---|
| Métrica | MCC | Accidentista | Accidentista | Lancero | Accidentista | Accidentista | Accidentista | Accidentista | Em | Em | F1 |
| Electra-grande | 69.1 | 96.9 | 90.8 | 92.6 | 92.4 | 90.9 | 95.0 | 88.0 | 89.7 | 88.1 | 97.2 |
| Electra-base | 67.7 | 95.1 | 89.5 | 91.2 | 91.5 | 88.8 | 93.2 | 82.7 | 86.8 | 80.5 | 97.1 |
| Electro-pequeña | 57.0 | 91.2 | 88.0 | 87.5 | 89.0 | 81.3 | 88.4 | 66.7 | 75.8 | 70.1 | 96.5 |
| Electro-pala | 56.8 | 88.3 | 87.4 | 86.8 | 88.3 | 78.9 | 87.9 | 68.5 | - | - | - |
Vea aquí para obtener pérdidas / curvas de entrenamiento de los modelos durante la capacitación previa.
Para entrenar electricidad, use el mismo script y comando de pre-entrenamiento que Electra. Pase "electra_objective": false y "electric_objective": true a los hiperparámetros. ¡Planeamos lanzar modelos eléctricos previamente capacitados pronto!
Si usa este código para su publicación, cite el documento original:
@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 usa el código para electricidad, cite el papel eléctrico:
@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}
}
Para obtener ayuda o problemas con Electra, envíe un problema de GitHub.
Para la comunicación personal relacionada con Electra, comuníquese con Kevin Clark ( [email protected] ).
