xlnet_sequence_tagging
1.0.0
Estamos desenvolvendo este projeto para marcar tarefas que o NLPER sempre atende.
Use o XLNet para as seguintes tarefas
Alarme, esses códigos ainda não foram concluídos. Seja cauteloso de usar.
Por exemplo, execute os SCIPTs usando:
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://universaldependences.org/
Você pode usar "Find ./ -name *test/dev/tren.conll" para encontrar todos os arquivos conll e usar xargs para copiá -los para data_dir
https://github.com/yuchenlin/ontonotes-5.0-ner-bio
Basta copiar os arquivos em inglês para data_dir usando o arquivo de script python: onotonotes_conll_copyfile.py (pode ser necessário modificar os caminhos)
PRs são bem -vindos! Por favor, ajude com o projeto em desenvolvimento para aprimorar nosso poder de PNL!
O XLNET é um novo método de aprendizado de representação de idiomas não supervisionado com base em um novo objetivo de modelagem de linguagem de permutação generalizada. Além disso, o XLNET emprega o transformador-xl como modelo de backbone, exibindo excelente desempenho para tarefas de idiomas envolvendo um longo contexto. No geral, o XLNET atinge os resultados de última geração (SOTA) em várias tarefas de linguagem a jusante, incluindo resposta a perguntas, inferência de linguagem natural, análise de sentimentos e classificação de documentos.
Para uma descrição detalhada de detalhes técnicos e resultados experimentais, consulte nosso artigo:
XLNET: pré -treinamento auto -regressivo generalizado para compreensão da linguagem
Zhilin Yang*, Zihang Dai*, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, Quoc V. Le
(*: Igual contribuição)
Preprint 2019
Em 19 de junho de 2019, o XLNet supera Bert em 20 tarefas e atinge resultados de ponta em 18 tarefas. Abaixo estão alguma comparação entre XLNet-Large e Bert-Large, que têm tamanhos de modelo semelhantes:
| Modelo | Precisão da corrida | Esquadrão1.1 em | Esquadrão2.0 Em |
|---|---|---|---|
| Bert-Large | 72.0 | 84.1 | 78.98 |
| XLNET-BASE | 80.18 | ||
| XLNET-LARGE | 81,75 | 88.95 | 86.12 |
Usamos o Squad Dev resulta na tabela para excluir outros fatores, como o uso de dados de treinamento adicionais ou outras técnicas de aumento de dados. Consulte a tabela de classificação do esquadrão para números de teste.
| Modelo | IMDB | Yelp-2 | Yelp-5 | Dbpedia | Amazon-2 | Amazon-5 |
|---|---|---|---|---|---|---|
| Bert-Large | 4.51 | 1.89 | 29.32 | 0,64 | 2.63 | 34.17 |
| XLNET-LARGE | 3.79 | 1.55 | 27.80 | 0,62 | 2.40 | 32.26 |
Os números acima são taxas de erro.
| Modelo | Mnli | Qnli | Qqp | Rte | SST-2 | Mrpc | Cola | STS-B |
|---|---|---|---|---|---|---|---|---|
| Bert-Large | 86.6 | 92.3 | 91.3 | 70.4 | 93.2 | 88.0 | 60.6 | 90.0 |
| XLNET-BASE | 86.8 | 91.7 | 91.4 | 74.0 | 94.7 | 88.2 | 60.2 | 89.5 |
| XLNET-LARGE | 89.8 | 93.9 | 91.8 | 83.8 | 95.6 | 89.2 | 63.6 | 91.8 |
Utilizamos resulta de dev uma tarefa única na tabela para excluir outros fatores, como aprendizado de várias tarefas ou usar conjuntos.
Em 16 de julho de 2019, os seguintes modelos foram disponibilizados:
XLNet-Large, Cased : 24 camadas, 1024-Hidden, 16 cabeçasXLNet-Base, Cased : 12 camadas, 768-Hidden, 12 cabeças. Este modelo é treinado em dados completos (diferente daquele no papel).Somente lançamos modelos CASED por enquanto, porque nas tarefas que consideramos, encontramos: (1) Para a configuração base, modelos revestidos e não baseados têm desempenho semelhante; (2) Para a configuração grande, os modelos revestidos são um pouco melhores em algumas tarefas.
Cada arquivo .zip contém três itens:
xlnet_model.ckpt ) contendo os pesos pré-treinados (que na verdade são 3 arquivos).spiece.model ) usado para (DE) tokenização.xlnet_config.json ) que especifica os hiperparâmetros do modelo.Também planejamos lançar continuamente modelos mais pré -gravados em diferentes configurações, incluindo:
Para receber notificações sobre atualizações, anúncios e novos lançamentos, recomendamos assinar o XLNET no Google Grupos.
Em 19 de junho de 2019, esta base de código foi testada com o Tensorflow 1.13.1 sob o Python2.
XLNet-Large resulta no artigo usando GPUs com 12 GB-16 GB de RAM, porque uma GPU de 16 GB é capaz de manter uma única sequência com o comprimento 512 para XLNet-Large . Portanto, é necessário um número grande (variando de 32 a 128, igual a batch_size ) das GPUs para reproduzir muitos resultados no artigo. Dado o problema da memória mencionado acima, usando os scripts Finetuning padrão ( run_classifier.py e run_squad.py ), comparamos o tamanho máximo do lote em uma única GPU de 16 GB com Tensorflow 1.13.1 :
| Sistema | Comprimento seq | Tamanho máximo em lote |
|---|---|---|
XLNet-Base | 64 | 120 |
| ... | 128 | 56 |
| ... | 256 | 24 |
| ... | 512 | 8 |
XLNet-Large | 64 | 16 |
| ... | 128 | 8 |
| ... | 256 | 2 |
| ... | 512 | 1 |
Na maioria dos casos, é possível reduzir o tamanho do lote train_batch_size ou o comprimento da sequência máxima max_seq_length para caber em hardware determinado. A diminuição do desempenho depende da tarefa e dos recursos disponíveis.
O código usado para executar a classificação/regressão finetuning está no run_classifier.py . Ele também contém exemplos de classificação padrão de um documento, regressão de um documento e classificação de pares de documentos. Aqui, fornecemos dois exemplos concretos de como run_classifier.py pode ser usado.
A partir daqui, assumimos que o XLNET-Large e o XLNET-BASE foram baixados para $LARGE_DIR e $BASE_DIR respectivamente.
Faça o download dos dados de cola executando este script e descompacte em algum diretório $GLUE_DIR .
Realize o Finetuning multi-GPU (4 V100 GPUS) com XLNet-Large executando
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=TrueAvalie os resultados da Finetuning com uma única GPU por
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+ "Notas :
num_core_per_host denota o número de GPUs a serem usadas.train_batch_size refere-se ao tamanho do lote por GPU.eval_all_ckpt permite avaliar todos os pontos de verificação salvos (a frequência de salvamento é controlada pelo save_steps ) após o acabamento do treinamento e escolha o melhor modelo com base no desempenho do desenvolvedor.data_dir e output_dir consulte os diretórios dos "dados brutos" e "TFRecords pré -processados", respectivamente, enquanto model_dir é o diretório de trabalho para salvar pontos de verificação e eventos de tensorflow. model_dir deve ser definido como uma pasta separada como init_checkpoint .--train_batch_size=32 e --num_core_per_host=1 , juntamente com as alterações de acordo com init_checkpoint e model_config_path .train_batch_size e aumente num_core_per_host para usar a mesma configuração de treinamento.Baixe e descompacte o conjunto de dados do IMDB executando
wget http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz
tar zxvf aclImdb_v1.tar.gzInicie uma instância do Google Cloud TPU V3-8 (consulte o tutorial do Google Cloud TPU sobre como configurar o Cloud TPUS).
Configure seu caminho de balde de armazenamento do Google $GS_ROOT e mova o conjunto de dados IMDB e o ponto de verificação pré -treinado no seu armazenamento do Google.
Realize TPU Finetuning com XLNet-Large executando
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+ "Notas :
data_dir e spiece_model_file usam um caminho local em vez de um caminho de armazenamento do Google. O motivo é que o pré -processamento de dados é realmente realizado localmente. Portanto, o uso de caminhos locais leva a uma velocidade de pré -processamento mais rápida. O código do conjunto de dados do esquadrão está incluído em run_squad.py .
Para executar o código:
(1) Faça o download do conjunto de dados Squad2.0 em $SQUAD_DIR por:
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) Execute o pré -processamento de dados usando os scripts/prepro_squad.sh .
Isso levará algum tempo para mapear com precisão as posições dos caracteres (dados brutos) para frase as posições da peça (usadas para treinamento).
Para um pré -processamento paralelo mais rápido, consulte os sinalizadores --num_proc e --proc_id em run_squad.py .
(3) Realizar treinamento e avaliação.
Para o melhor desempenho, o XLNET-Large usa o comprimento da sequência 512 e o tamanho do lote 48 para treinamento.
Como resultado, a reprodução do melhor resultado com as GPUs é bastante difícil.
Para treinamento com um TPU V3-8, pode-se simplesmente executar os scripts/tpu_squad_large.sh depois que a TPU e o armazenamento do Google foram configurados.
run_squad.py executará automaticamente a pesquisa limite no conjunto de dev do esquadrão e produzirá a pontuação. Com scripts/tpu_squad_large.sh , a pontuação F1 esperada deve ser de cerca de 88,6 (mediana de nossas múltiplas execuções).
Como alternativa, pode-se usar XLNet-Base com GPUs (por exemplo, três V100). Um conjunto de hiper-parâmetros razoáveis pode ser encontrado nos scripts/gpu_squad_base.sh .
O código para a corrida de tarefas de compreensão de leitura está incluído em run_race.py .
Para executar o código:
(1) Faça o download do conjunto de dados de corrida no site oficial e descompacte os dados brutos para $RACE_DIR .
(2) Realizar treinamento e avaliação:
script/tpu_race_large_bsz32.sh para esta configuração.script/tpu_race_large_bsz8.sh ).Um exemplo de uso do Google Colab com GPUs foi fornecido. Observe que, como o hardware é restrito no exemplo, os resultados são piores que os melhores que podemos obter. Serve principalmente como exemplo e deve ser modificado de acordo para maximizar o desempenho.
Para o Finetuning, é provável que você possa modificar arquivos existentes como run_classifier.py , run_squad.py e run_race.py para sua tarefa em mãos. No entanto, também fornecemos uma abstração do XLNET para permitir o uso mais flexível. Abaixo está um exemplo:
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`Abaixo está um exemplo de tokenização no 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 ) onde FLAGS.spiece_model_file é o arquivo de modelo de peça de sentença no mesmo zip que o modelo pré -terenciado, FLAGS.uncased .
Consulte train.py para pré -treinamento no TPUS e train_gpu.py para pré -treinamento nas GPUs. Primeiro, precisamos pré -processar os dados de texto em 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 Onde input_glob define todos os arquivos de texto de entrada, save_dir é o diretório de saída para o TFRecords, e sp_path é um modelo de peça de frase. Aqui está o nosso script para treinar o modelo de peça de frase
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 São usados símbolos especiais, incluindo control_symbols e user_defined_symbols . Usamos <eop> e <eod> para denotar o final do parágrafo e o final do documento, respectivamente.
Os arquivos de texto de entrada para data_utils.py devem usar o seguinte formato:
<eop> pode ser inserido no final de certas linhas (sem nenhum espaço) para indicar que a frase correspondente termina um parágrafo.Por exemplo, o arquivo de entrada de texto pode ser:
This is the first sentence.
This is the second sentence and also the end of the paragraph.<eop>
Another paragraph.
Another document starts here.
Após o pré -processamento, estamos prontos para pré -extrair um XLNet. Abaixo estão os hiperparâmetros usados para pré-treinar XLNet-Large:
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=85onde listamos apenas os sinalizadores mais importantes e os outros sinalizadores podem ser ajustados com base em casos de uso específicos.
