xlnet_sequence_tagging
1.0.0
Estamos desarrollando este proyecto para etiquetar tareas que NLPER siempre cumple.
Use XLNet para las siguientes tareas
Alarma, estos códigos aún no están terminados. Tenga cuidado de usar.
Por ejemplo, ejecute los 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://universaldependencies.org/
Puede usar "Buscar ./ -name *test/dev/train.conll" para encontrar todos los archivos de conll y usar XARGS para copiarlos a data_dir
https://github.com/yuchenlin/ontonotes-5.0-ner-bio
Simplemente copie los archivos en inglés a data_dir usando el archivo de script de Python: onoTonotes_conll_copyfile.py (es posible que necesite modificar las rutas)
¡Los pr s son bienvenidos! ¡Ayuda con el proyecto en desarrollo para mejorar nuestra potencia de PNL!
XLNet es un nuevo método de aprendizaje de representación de lenguaje no supervisado basado en un nuevo objetivo de modelado de lenguaje de permutación generalizada. Además, XLNet emplea Transformer-XL como modelo de columna vertebral, exhibiendo un excelente rendimiento para tareas de lenguaje que involucran un contexto largo. En general, XLNet logra los resultados de última generación (SOTA) en varias tareas de lenguaje posterior, incluida la respuesta a las preguntas, la inferencia del lenguaje natural, el análisis de sentimientos y la clasificación de documentos.
Para obtener una descripción detallada de los detalles técnicos y los resultados experimentales, consulte nuestro artículo:
XLNet: Pretratenamiento autorregresivo generalizado para la comprensión del lenguaje
Zhilin Yang*, Zihang Dai*, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, Quoc V. Le
(*: Contribución igual)
Preimpresión 2019
Al 19 de junio de 2019, XLNet supera a Bert en 20 tareas y logra resultados de última generación en 18 tareas. A continuación se presentan algunas comparaciones entre XLNet-Large y Bert-Large, que tienen tamaños de modelo similares:
| Modelo | Precisión de la carrera | Escuadrón1.1 em | Squad2.0 em |
|---|---|---|---|
| Bernemacia | 72.0 | 84.1 | 78.98 |
| Base xlnet | 80.18 | ||
| Xlnet-grande | 81.75 | 88.95 | 86.12 |
Utilizamos los resultados de desarrollo de escuadrón en la tabla para excluir otros factores, como el uso de datos de capacitación adicionales u otras técnicas de aumento de datos. Ver tabla de clasificación de escuadrón para los números de prueba.
| Modelo | IMDB | Yelp-2 | Yelp-5 | Dbpedia | Amazon-2 | Amazon-5 |
|---|---|---|---|---|---|---|
| Bernemacia | 4.51 | 1.89 | 29.32 | 0.64 | 2.63 | 34.17 |
| Xlnet-grande | 3.79 | 1.55 | 27.80 | 0.62 | 2.40 | 32.26 |
Los números anteriores son las tasas de error.
| Modelo | Mnli | Qnli | QQP | RTE | SST-2 | MRPC | Reajuste salarial | STS-B |
|---|---|---|---|---|---|---|---|---|
| Bernemacia | 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-grande | 89.8 | 93.9 | 91.8 | 83.8 | 95.6 | 89.2 | 63.6 | 91.8 |
Utilizamos resultados de desarrollo de tareas únicas en la tabla para excluir otros factores, como el aprendizaje de varias tareas o el uso de conjuntos.
A partir del 16 de julio de 2019, se han puesto a disposición los siguientes modelos:
XLNet-Large, Cased : 24 capas, 1024 escondidas, 16 cabezasXLNet-Base, Cased : 12 capas, 768 escondidas, 12 cabezas. Este modelo está capacitado en datos completos (diferente al del documento).Solo liberamos modelos en escenario por ahora porque en las tareas que consideramos, encontramos: (1) para la configuración base, los modelos caros y no basados tienen un rendimiento similar; (2) Para la configuración grande, los modelos con carcasa son un poco mejores en algunas tareas.
Cada archivo .zip contiene tres elementos:
xlnet_model.ckpt ) que contiene los pesos previamente capacitados (que en realidad son 3 archivos).spiece.model ) utilizado para (de) tokenización.xlnet_config.json ) que especifica los hiperparámetros del modelo.También planeamos liberar continuamente más modelos previos a los pretrados en diferentes entornos, que incluyen:
Para recibir notificaciones sobre actualizaciones, anuncios y nuevos lanzamientos, recomendamos suscribirse al XLNet en los grupos de Google.
Al 19 de junio de 2019, esta base de código se ha probado con TensorFlow 1.13.1 bajo Python2.
XLNet-Large en el documento utilizando GPU con 12 GB-16 GB de RAM, porque una GPU de 16 GB solo puede contener una secuencia única con longitud 512 para XLNet-Large . Por lo tanto, se requiere un gran número (que oscila entre 32 y 128, igual a batch_size ) de las GPU para reproducir muchos resultados en el documento. Dado el problema de la memoria mencionado anteriormente, utilizando los scripts de finuning predeterminados ( run_classifier.py y run_squad.py ), comparamos el tamaño máximo de lotes en una sola GPU de 16 GB con TensorFlow 1.13.1 :
| Sistema | Longitud de SEQ | Tamaño de lote máximo |
|---|---|---|
XLNet-Base | 64 | 120 |
| ... | 128 | 56 |
| ... | 256 | 24 |
| ... | 512 | 8 |
XLNet-Large | 64 | 16 |
| ... | 128 | 8 |
| ... | 256 | 2 |
| ... | 512 | 1 |
En la mayoría de los casos, es posible reducir el tamaño por lotes train_batch_size o la longitud de secuencia máxima max_seq_length para adaptarse al hardware dado. La disminución del rendimiento depende de la tarea y los recursos disponibles.
El código utilizado para realizar la clasificación/regresión Finetuning está en run_classifier.py . También contiene ejemplos para la clasificación estándar de un documento, regresión de un documento y clasificación de pares de documentos. Aquí, proporcionamos dos ejemplos concretos de cómo se puede usar run_classifier.py .
A partir de aquí, suponemos que XLNet-Large y XLNet-Base se han descargado a $LARGE_DIR y $BASE_DIR respectivamente.
Descargue los datos de pegamento ejecutando este script y desempaquetelo en algún directorio $GLUE_DIR .
Realizar finetos multi-GPU (4 V100 GPU) con XLNet-Large ejecutándose
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=TrueEvaluar los resultados de Finetuning con una sola 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 el número de GPU para usar.train_batch_size se refiere al tamaño de lote por GPU.eval_all_ckpt permite que uno evalúe todos los puntos de control guardados (Save Frecuencia se controla mediante save_steps ) después de finalizar el entrenamiento y elegir el mejor modelo basado en el rendimiento del desarrollo.data_dir y output_dir consulte los directorios de los "datos sin procesar" y "TFRecords preprocesados" respectivamente, mientras que model_dir es el directorio de trabajo para guardar puntos de control y eventos de flujo de tensor. model_dir debe establecerse como una carpeta separada para init_checkpoint .--train_batch_size=32 y --num_core_per_host=1 , junto con los cambios en init_checkpoint y model_config_path .train_batch_size y aumente num_core_per_host para usar la misma configuración de entrenamiento.Descargar y desempaquetar el conjunto de datos IMDB ejecutando
wget http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz
tar zxvf aclImdb_v1.tar.gzInicie una instancia de Google Cloud TPU V3-8 (consulte el tutorial de Google Cloud TPU sobre cómo configurar TPUS en la nube).
Configure su ruta de cubo de almacenamiento de Google $GS_ROOT y mueva el conjunto de datos IMDB y el punto de control previamente prestado a su almacenamiento en Google.
Realizar TPU Finetuning con XLNet-Large ejecutando
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 y spiece_model_file usan una ruta local en lugar de una ruta de almacenamiento de Google. La razón es que el preprocesamiento de datos en realidad se realiza localmente. Por lo tanto, el uso de rutas locales conduce a una velocidad de preprocesamiento más rápida. El código para el conjunto de datos del escuadrón se incluye en run_squad.py .
Para ejecutar el código:
(1) Descargue el conjunto de datos Squad2.0 en $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) Realice el preprocesamiento de datos utilizando el script scripts/prepro_squad.sh .
Esto llevará bastante tiempo para mapear con precisión las posiciones de los caracteres (datos sin procesar) a las posiciones de las piezas de oración (utilizadas para el entrenamiento).
Para un preprocesamiento paralelo más rápido, consulte las banderas --num_proc y --proc_id en run_squad.py .
(3) Realizar capacitación y evaluación.
Para el mejor rendimiento, XLNet-Large utiliza la longitud de secuencia 512 y el tamaño de lotes 48 para el entrenamiento.
Como resultado, reproducir el mejor resultado con GPU es bastante difícil.
Para entrenar con un TPU V3-8, simplemente se puede ejecutar el script scripts/tpu_squad_large.sh después de que se haya configurado TPU y Google Storage.
run_squad.py realizará automáticamente la búsqueda de umbral en el conjunto de desarrollo del escuadrón y emitirá la puntuación. Con scripts/tpu_squad_large.sh , el puntaje F1 esperado debe ser de alrededor de 88.6 (mediana de nuestras múltiples carreras).
Alternativamente, se puede usar la base XLNet con GPU (por ejemplo, tres V100). Se puede encontrar un conjunto de hiper-parámetros razonables en el script scripts/gpu_squad_base.sh .
El código para la carrera de tareas de comprensión de lectura se incluye en run_race.py .
Para ejecutar el código:
(1) Descargue el conjunto de datos de carrera del sitio web oficial y desempaquete los datos sin procesar a $RACE_DIR .
(2) Realizar capacitación y evaluación:
script/tpu_race_large_bsz32.sh para esta configuración.script/tpu_race_large_bsz8.sh ).Se ha proporcionado un ejemplo del uso de Google Colab con GPU. Tenga en cuenta que dado que el hardware está limitado en el ejemplo, los resultados son peores que los mejores que podemos obtener. Sirve principalmente como ejemplo y debe modificarse en consecuencia para maximizar el rendimiento.
Para Finetuning, es probable que pueda modificar los archivos existentes como run_classifier.py , run_squad.py y run_race.py para su tarea en cuestión. Sin embargo, también proporcionamos una abstracción de XLNet para habilitar un uso más flexible. A continuación se muestra un ejemplo:
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`A continuación se muestra un ejemplo de tokenización en 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 ) Donde FLAGS.spiece_model_file es el archivo del modelo de la pieza de oración en la misma zip que el modelo previamente practicado, FLAGS.uncased es un bool que indica si se debe hacer.
Consulte train.py para realizar previamente elaborado en TPUS y train_gpu.py para realizar previamente las GPU. Primero necesitamos preprocesar los datos de texto 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 Donde input_glob define todos los archivos de texto de entrada, save_dir es el directorio de salida para TFRecords, y sp_path es un modelo de pieza de oración. Aquí está nuestro guión para entrenar el modelo de pieza de oración
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 Se utilizan símbolos especiales, incluidos control_symbols y user_defined_symbols . Usamos <eop> y <eod> para denotar el final del párrafo y el final del documento respectivamente.
Los archivos de texto de entrada a data_utils.py deben usar el siguiente formato:
<eop> se puede insertar al final de ciertas líneas (sin ningún espacio) para indicar que la oración correspondiente finaliza un párrafo.Por ejemplo, el archivo de entrada de texto podría 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.
Después del preprocesamiento, estamos listos para previamente a un XLNet. A continuación se muestran los hiperparámetros utilizados para pretrarse 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=85Donde solo enumeramos las banderas más importantes y las otras banderas podrían ajustarse en función de casos de uso específicos.
