electra
1.0.0
Electra é um método para o aprendizado de representação de idiomas auto-supervisionado. Pode ser usado para pré-treinar redes de transformadores usando relativamente pouca computação. Os modelos Electra são treinados para distinguir tokens de entrada "reais" de entrada versus "falsos", gerados por outra rede neural, semelhante ao discriminador de um GaN. Em pequena escala, a Electra alcança fortes resultados mesmo quando treinados em uma única GPU. Em larga escala, a Electra alcança resultados de última geração no conjunto de dados do Esquadrão 2.0.
Para uma descrição detalhada e resultados experimentais, consulte nosso ICLR 2020 Paper Electra: Codificadores de texto pré-treinamento como discriminadores e não geradores.
Este repositório contém código para pré-treinar electra, incluindo pequenos modelos Electra em uma única GPU. Ele também suporta electra de ajuste fino em tarefas a jusante, incluindo tarefas de classificação (por exemplo, cola), tarefas de controle de qualidade (por exemplo, esquadrão) e tarefas de marcação de sequência (por exemplo, chunking de texto).
Este repositório também contém código para a Electric , uma versão do Electra inspirada em modelos baseados em energia. A Electric fornece uma visão mais com princípios do Electra como um modelo de cloze "amostragem negativa". Também pode produzir com eficiência pontuações de pseudo-likelinco para texto, que podem ser usadas para re-classificar as saídas dos sistemas de reconhecimento de fala ou tradução de máquinas. Para detalhes sobre a Electric, consulte os transformadores de pré-treinamento em papel EMNLP 2020 como modelos de cloze baseados em energia.
Inicialmente, estamos lançando três modelos pré-treinados:
| Modelo | Camadas | Tamanho oculto | Params | Pontuação de cola (conjunto de testes) | Download |
|---|---|---|---|---|---|
| Electra-small | 12 | 256 | 14m | 77.4 | link |
| Electra-Base | 12 | 768 | 110m | 82.7 | link |
| Electra-grande | 24 | 1024 | 335m | 85.2 | link |
Os modelos foram treinados em texto em inglês não baseado. Eles correspondem a Electra-Small ++, Electra-Base ++, Electra-1,75m em nosso papel. Esperamos lançar outros modelos, como modelos multilíngues, no futuro.
Na cola, os escores electra-largura são um pouco melhores que o Albert/XLNET, os escores do Electra-BASE melhor que o Bert-Large e os escores de electra-minúsculos um pouco piores que Tinybert (mas não usa destilação). Veja a seção de resultados esperados abaixo para obter números de desempenho detalhados.
Use build_pretraining_dataset.py para criar um conjunto de dados de pré-treinamento a partir de um despejo de texto bruto. Tem os seguintes argumentos:
--corpus-dir : Um diretório que contém arquivos de texto bruto para se transformar em exemplos de electra. Um arquivo de texto pode conter vários documentos com linhas vazias que os separam.--vocab-file : Arquivo Definindo o vocabulário da peça de palavra.--output-dir : onde escrever exemplos de electra.--max-seq-length : o número de tokens por exemplo (128 por padrão).--num-processes : se> 1 paralalize em vários processos (1 por padrão).--blanks-separate-docs : se as linhas em branco indicam limites de documentos (true por padrão).--do-lower-case/--no-lower-case : se deve a menor estojo o texto de entrada (true por padrão). Use run_pretraining.py para pré-treinar um modelo Electra. Tem os seguintes argumentos:
--data-dir : um diretório em que os dados pré-treinamento, pesos do modelo etc. são armazenados. Por padrão, o treinamento carrega exemplos de <data-dir>/pretrain_tfrecords e um vocabulário de <data-dir>/vocab.txt .--model-name : um nome para o modelo que está sendo treinado. Os pesos do modelo serão salvos em <data-dir>/models/<model-name> por padrão.--hparams (opcional): um ditado ou caminho json para um arquivo JSON contendo hiperparameters do modelo, caminhos de dados etc. Consulte configure_pretraining.py para os hiperparâmetros suportados. Se o treinamento for interrompido, executar novamente o run_pretraining.py com os mesmos argumentos continuará o treinamento de onde parou.
Você pode continuar pré-treinamento a partir dos pontos de verificação de electra liberados por
--model-name electra_small se você baixou pesos para $DATA_DIR/electra_small ).num_train_steps por (por exemplo) adicionando "num_train_steps": 4010000 aos --hparams . Isso continuará treinando o modelo pequeno para mais 10000 etapas (já foi treinado para 4e6 etapas).learning_rate como 2E-4 * (4E6 + 10000) / 10000."generator_hidden_size": 1.0 nos hparams porque não usamos um pequeno gerador para esse modelo. Essas instruções pré-trepam um pequeno modelo Electra (12 camadas, 256 tamanho oculto). Infelizmente, os dados que usamos no artigo não estão disponíveis ao público, por isso usaremos o OpenWebTextCorpus lançado por Aaron Gokaslan e Vanya Cohen. O modelo totalmente treinado (~ 4 dias em uma GPU V100) deve ter um desempenho aproximado entre GPT e Bert-Base em termos de desempenho de cola. Por padrão, o modelo é treinado nas sequências LIMPE-128, por isso não é adequado para executar no atendimento de perguntas. Consulte a seção "Resultados esperados" abaixo para obter mais detalhes sobre o desempenho do modelo.
$DATA_DIR/vocab.txt . Nossos modelos Electra usaram exatamente o mesmo vocabulário que o inglês não baseado Bert, que você pode baixar aqui.tar xf openwebtext.tar.xz ). Coloque -o em $DATA_DIR/openwebtext .python3 build_openwebtext_pretraining_dataset.py --data-dir $DATA_DIR --num-processes 5 . Ele pré-processos/tokeniza os exemplos de dados e saída como arquivos tfrecord sob $DATA_DIR/pretrain_tfrecords . Os TfRecords requerem aproximadamente 30g de espaço em disco. Execute python3 run_pretraining.py --data-dir $DATA_DIR --model-name electra_small_owt para treinar um pequeno modelo Electra para 1 milhão de etapas nos dados. Isso leva um pouco mais de 4 dias em uma GPU Tesla V100. No entanto, o modelo deve obter resultados decentes após 200 mil etapas (10 horas de treinamento na GPU V100).
Para personalizar o treinamento, adicione --hparams '{"hparam1": value1, "hparam2": value2, ...}' para o comando run. --hparams também podem ser um caminho para um arquivo .json que contém os hiperparâmetros. Algumas opções particularmente úteis:
"debug": true treina um pequeno modelo Electra para algumas etapas."model_size": one of "small", "base", or "large" : determina o tamanho do modelo"electra_objective": false trens um modelo com modelagem de linguagem mascarada em vez de detecção de token substituída (essencialmente com máscara dinâmica e nenhuma previsão da próxima frase)."num_train_steps": n controla quanto tempo o modelo é pré-treinado."pretrain_tfrecords": <paths> determina onde os dados de pré-treinamento estão localizados. NOTA Você precisa especificar os arquivos específicos não apenas o diretório (por exemplo, <data-dir>/pretrain_tf_records/pretrain_data.tfrecord* )"vocab_file": <path> e "vocab_size": n pode ser usado para definir um vocabulário personalizado."learning_rate": lr, "train_batch_size": n , etc. pode ser usado para alterar os hiperparâmetros de treinamento"model_hparam_overrides": {"hidden_size": n, "num_hidden_layers": m} , etc. pode ser usado para alterar os hiperparameters para o transformador subjacente (o sinalizador "model_size" define os valores padrão). Consulte configure_pretraining.py para obter o conjunto completo de hiperparâmetros suportados.
Para avaliar o modelo em uma tarefa a jusante, consulte as instruções do Finetuning abaixo. Para avaliar o gerador/discriminador nos dados do OpenWebtext, execute python3 run_pretraining.py --data-dir $DATA_DIR --model-name electra_small_owt --hparams '{"do_train": false, "do_eval": true}' . Isso imprimirá as métricas de Eval, como a precisão do gerador e discriminador, e também escrevendo as métricas para obter data-dir/model-name/results .
Use run_finetuning.py para ajustar e avaliar um modelo Electra em uma tarefa de PNL a jusante. Espera três argumentos:
--data-dir : um diretório em que dados, pesos do modelo, etc. são armazenados. Por padrão, o script carrega os dados do Finetuning de <data-dir>/finetuning_data/<task-name> e um vocabulário de <data-dir>/vocab.txt .--model-name : um nome do modelo pré-treinado: os pesos pré-treinados devem existir no data-dir/models/model-name .--hparams : um ditado JSON contendo hiperparâmetros de modelo, caminhos de dados, etc. (por exemplo, --hparams '{"task_names": ["rte"], "model_size": "base", "learning_rate": 1e-4, ...}' ). Consulte configure_pretraining.py para os hiperparâmetros suportados. Em vez de um ditado, esse também pode ser um caminho para um arquivo .json contendo os hiperparâmetros. Você deve especificar os "task_names" e "model_size" (veja os exemplos abaixo). As métricas de EVVEN serão salvas em data-dir/model-name/results e Model Weights serão salvos no data-dir/model-name/finetuning_models por padrão. A avaliação é feita no Dev definido por padrão. Para personalizar o treinamento, adicione --hparams '{"hparam1": value1, "hparam2": value2, ...}' para o comando run. Algumas opções particularmente úteis:
"debug": true Fine Tunes Um pequeno modelo Electra para algumas etapas."task_names": ["task_name"] : Especifica as tarefas para treinar. Uma lista porque a Base CodeBase suporta nominalmente aprendizado de várias tarefas (embora seja avisado, isso não foi testado minuciosamente)."model_size": one of "small", "base", or "large" : determina o tamanho do modelo; Você deve definir isso do mesmo tamanho que o modelo pré-treinado."do_train" and "do_eval" : treinar e/ou avaliar um modelo (ambos são definidos como true por padrão). Para usar "do_eval": true com "do_train": false , você precisa especificar o init_checkpoint , por exemplo, 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 : se> 1, o ajuste/avaliação múltipla é executado com diferentes sementes aleatórias."learning_rate": lr, "train_batch_size": n , etc. pode ser usado para alterar os hiperparâmetros de treinamento."model_hparam_overrides": {"hidden_size": n, "num_hidden_layers": m} , etc. pode ser usado para alterar os hiperparameters para o transformador subjacente (o sinalizador "model_size" define os valores padrão). Obtenha um modelo Electra pré-treinado treinando seus próprios (consulte as instruções de pré-treinamento acima) ou baixando os pesos electra de liberação e descompactando-os sob $DATA_DIR/models (por exemplo, você deve ter um diretório $DATA_DIR/models/electra_large se estiver usando o modelo grande).
Faça o download dos dados de cola executando este script. Configure os dados executando 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 .
Em seguida, execute run_finetuning.py . Por exemplo, para ajustar o electra-base no MNLI
python3 run_finetuning.py --data-dir $DATA_DIR --model-name electra_base --hparams '{"model_size": "base", "task_names": ["mnli"]}'
Ou ajuste um modelo pequeno pré-treinado usando as instruções acima no cola.
python3 run_finetuning.py --data-dir $DATA_DIR --model-name electra_small_owt --hparams '{"model_size": "small", "task_names": ["cola"]}'
O código suporta o Esquadrão 1.1 e 2.0, bem como conjuntos de dados na tarefa compartilhada do MRQA de 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 .Em seguida, corra (por exemplo)
python3 run_finetuning.py --data-dir $DATA_DIR --model-name electra_base --hparams '{"model_size": "base", "task_names": ["squad"]}'
Este repositório usa o código de avaliação oficial divulgado pelos autores do esquadrão e a tarefa compartilhada do MRQA para calcular métricas
Faça o download do conjunto de dados de Chunking de texto Conll-2000 aqui e coloque-o em $DATA_DIR/finetuning_data/chunk/(train|dev).txt . Em seguida, corra
python3 run_finetuning.py --data-dir $DATA_DIR --model-name electra_base --hparams '{"model_size": "base", "task_names": ["chunk"]}'
A maneira mais fácil de executar em uma nova tarefa é implementar um novo finetune.task.Task , adicione -o ao finetune.task_builder.py e depois use run_finetuning.py normalmente. Para marcação de classificação/QA/sequência, você pode herdar de um finetune.classification.classification_tasks.ClassificationTask , finetune.qa.qa_tasks.QATask , ou finetune.tagging.tagging_tasks.TaggingTask . Para dados de pré -processamento, usamos o mesmo tokenizer que Bert.
Aqui estão os resultados esperados para o Electra em várias tarefas (conjunto de testes para Chunking, Dev definido para as outras tarefas). Observe que a variação no ajuste fina pode ser bastante grande; portanto, para algumas tarefas, você pode ver grandes flutuações nas pontuações ao ajustar fino do mesmo ponto de verificação várias vezes. As pontuações abaixo mostram desempenho mediano em um grande número de sementes aleatórias. Electra-small/base/grande são nossos modelos lançados. Electra-small-owt é o modelo OpenWebtext treinado acima (ele tem um desempenho um pouco pior que o Electra-pequeno devido ao treinado por menos tempo e em um conjunto de dados menor).
| Cola | SST | Mrpc | Sts | Qqp | Mnli | Qnli | Rte | Esquadrão 1.1 | Esquadrão 2.0 | Chunking | |
|---|---|---|---|---|---|---|---|---|---|---|---|
| Métricas | MCC | Acc | Acc | Lanceiro | Acc | Acc | Acc | Acc | 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 |
| Electra-small | 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 | - | - | - |
Veja aqui para perdas / curvas de treinamento dos modelos durante o pré-treinamento.
Para treinar elétrico, use o mesmo script de pré-treinamento e comando que Electra. Passe "electra_objective": false e "electric_objective": true aos hiperparâmetros. Planejamos lançar modelos elétricos pré-treinados em breve!
Se você usar este código para sua publicação, cite o artigo 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}
}
Se você usar o código para elétrico, cite o papel elétrico:
@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 obter ajuda ou problemas usando o Electra, envie um problema do GitHub.
Para comunicação pessoal relacionada à Electra, entre em contato com Kevin Clark ( [email protected] ).
