text to text transfer transformer
v0.4.0
T5X es la nueva y mejorada implementación de T5 (y más) en Jax y Flax. T5 en Tensorflow con MeshTF ya no se desarrolla activamente. Si eres nuevo en T5, recomendamos comenzar con T5X.
La biblioteca t5 sirve principalmente como código para reproducir los experimentos en la exploración de los límites del aprendizaje de transferencia con un transformador de texto a texto unificado . En el documento, demostramos cómo lograr resultados de última generación en múltiples tareas de PNL utilizando un transformador de texto a texto previamente entrenado en un corpus de texto grande.
La mayor parte del código en este repositorio se utiliza para cargar, preprocesar, mezclar y evaluar conjuntos de datos. También proporciona una forma de ajustar los modelos previamente entrenados lanzados junto con la publicación.
La biblioteca t5 se puede utilizar para el desarrollo de modelos futuros al proporcionar módulos útiles para la capacitación y los modelos de ajuste fino (potencialmente enorme ) en mezclas de tareas de texto a texto.
t5.data es un paquete para definir objetos Task que proporcionan tf.data.Dataset s.
Cada Task está compuesta por:
Además, opcionalmente puede proporcionar:
La fuente de datos puede ser una función arbitraria que proporciona un tf.data.Dataset , pero también proporcionamos envoltorios más simples para conjuntos de datos disponibles en TensorFlow DataSets (TFDS) (una TfdsTask ) o almacenados como archivos de texto con un ejemplo por línea (una TextLineTask ) .
El preprocesador de texto convierte los ejemplos en el conjunto de datos de origen en el formato apropiado para un modelo de texto a texto con campos para inputs y targets . Por ejemplo, el t5.data.preprocessors.translate preprocesador convierte las entradas en el formulario
{ 'de' : 'Das ist gut.' , 'en' : 'That is good.' }a la forma
{ 'inputs' : 'translate German to English: Das ist gut.' , 'targets' : 'That is good.' }Además del preprocesamiento de texto, también puede usar uno o más preprocesadores de tokens para modificar las entradas después de la tokenización. Implementamos nuestros objetivos de pre-entrenamiento no supervisados utilizando estos preprocesadores de tokens.
Proporcionamos muchos preprocesadores predefinidos en t5.data.preprocessors , pero también puede definir los suyos.
El modelo de oración se utiliza para tokenizar las cadenas de entrada y decodificar los tokens de salida. Puede crear su propio modelo con la biblioteca Google/SentencePiece, o usar nuestro predeterminado en t5.data.DEFAULT_SPM_PATH . Si crea el suyo, debe usar los flags --pad_id=0 --eos_id=1 --unk_id=2 --bos_id=-1 con spm_train para ser compatible con nuestro código de modelo.
La función métrica devuelve una puntuación dado el objetivo y la predicción del modelo. También puede definir una función posterior al proceso para convertir el texto de destino y predicción a otro formato antes de llamar a la métrica. Proporcionamos algunas métricas predefinidas en t5.evaluation.metrics .
Finalmente, t5.data contiene una clase Mixture que se puede instanciar para combinar múltiples conjuntos de datos Task para el entrenamiento de tareas múltiples utilizando diversas funciones para especificar las tasas de mezcla.
t5.evaluation contiene dos componentes centrales:
t5.models contiene cuñas para conectar Tasks y Mixtures de T5 a una implementación del modelo para capacitación, evaluación e inferencia.
Actualmente hay dos cuñas disponibles: una para el transformador de Mesh TensorFlow que usamos en nuestro papel y otra para la Biblioteca de Transformadores de Face. La API de abrazadera de abrazos es actualmente experimental y está sujeto a cambios, pero proporciona una forma simple y fácil de cargar, afinar y evaluar nuestros modelos previamente capacitados utilizando Pytorch en una sola GPU. Si desea utilizar nuestros modelos más grandes en TPUS y/o reproducir los resultados en nuestro documento, debe usar la API MTFModel y el Binario t5_mesh_transformer . Si está interesado en ajustar nuestros modelos en una GPU en Pytorch, debe probar la API HFPyTorchModel. Dado que el hfpytorchmodel es experimental, el resto de este readme asume el uso del MTFModel y su binario asociado. Aquí está un ejemplo de uso de hfpytorchmodel está disponible aquí.
La forma más fácil de probar T5 es con una TPU gratuita en nuestro tutorial de Colab.
A continuación, proporcionamos ejemplos sobre cómo entrenar, ajustar, evaluar y decodificar desde un modelo desde la línea de comandos con nuestra base de código. Puede usar estas instrucciones para reproducir nuestros resultados, ajustar uno de nuestros puntos de control liberados con sus propios datos y/o hiperparámetros, o pre-entrenar un modelo desde cero.
Puede usar una Task nueva o preexistente, o puede cargar ejemplos de un archivo TSV preprocesado.
TaskDependiendo de su fuente de datos (ver arriba), deberá preparar sus datos adecuadamente.
Task Si usa una tarea de vainilla, solo asegúrese de que cualquier archivo cargado por su dataset_fn esté accesible para la TPU (es decir, esté en un cubo GCS), ¡y debería estar listo!
TfdsTask La mayoría de nuestras Task predefinidas usan conjuntos de datos TensorFlow (TFD) como su fuente de datos. Cuando ejecuta nuestro binario de capacitación (consulte las instrucciones a continuación) con una TfdsTask , el conjunto de datos se descargará y preparará automáticamente en su primer uso. Después de que se complete la preparación, el conjunto de datos se almacena en caché a su almacenamiento local para evitar esta sobrecarga en futuras ejecuciones. Si funciona en la nube, le recomendamos que configure el indicador --t5_tfds_data_dir para apuntar a una ubicación de almacenamiento persistente, como un cubo GCS. Este es un requisito al entrenar en TPU.
El conjunto de datos C4 que creamos para el pre-entrenamiento no supervisado está disponible en conjuntos de datos TensorFlow, pero requiere una cantidad significativa de ancho de banda para descargar los raspados de rastreo comunes sin procesar (~ 7 TB) y calcularse para su preparación (~ 335 días de CPU). Sugerimos que aproveche el soporte del haz Apache en TFDS, que permite el preprocesamiento distribuido del conjunto de datos y se puede ejecutar en Google Cloud DataFlow. Con 500 trabajadores, el trabajo debe completarse en ~ 16 horas.
Después de definir MY_PROJECT y MY_BUCKET de manera apropiada, puede construir el conjunto de datos en DataFlow desde GCP usando los siguientes comandos:
pip install tfds-nightly[c4]
echo ' tfds-nightly[c4] ' > /tmp/beam_requirements.txt
python -m tensorflow_datasets.scripts.download_and_prepare
--datasets=c4/en
--data_dir=gs:// $MY_BUCKET /tensorflow_datasets
--beam_pipeline_options= " project= $MY_PROJECT ,job_name=c4,staging_location=gs:// $MY_BUCKET /binaries,temp_location=gs:// $MY_BUCKET /temp,runner=DataflowRunner,requirements_file=/tmp/beam_requirements.txt,experiments=shuffle_mode=service,region= $MY_REGION "Lea más en las instrucciones del haz TFDS.
TextLineTask Una TextLineTask es útil cuando su fuente de datos es un archivo de texto (o archivos) con un ejemplo por línea. Luego puede usar un preprocesador de texto para convertir cada línea en un diccionario de entradas y objetivos.
Asegúrese de que sus archivos sean accesibles para la TPU (es decir, se encuentren en un cubo GCS), ¡y debería estar listo para comenzar!
En lugar de definir una nueva Task , puede usar un archivo TSV (o archivos) directamente como su conjunto de datos donde cada línea está formateada como <input>t<target> .
Sin embargo, hay un par de advertencias:
Si necesita alguna de estas funciones, debe definir una nueva Task , TfdsTask o TextLineTask .
Similar a los casos anteriores, sus archivos TSV deben ser accesibles para la TPU (es decir, están en un cubo GCS).
Para instalar el paquete T5, simplemente ejecute:
pip install t5[gcp]Primero deberá iniciar una máquina virtual (VM) en Google Cloud. Los detalles sobre el lanzamiento de la VM se pueden encontrar en la documentación de Google Cloud.
Para ejecutar capacitación o evaluación en TPUS en la nube, debe configurar las siguientes variables en función de su proyecto, zona y cubo GCS de manera adecuada. Consulte la Guía Cloud TPU QuickStart para obtener más detalles.
export PROJECT=your_project_name
export ZONE=your_project_zone
export BUCKET=gs://yourbucket/
export TPU_NAME=t5-tpu
export TPU_SIZE=v3-8
export DATA_DIR= " ${BUCKET} /your_data_dir "
export MODEL_DIR= " ${BUCKET} /your_model_dir "Utilice el siguiente comando para crear un dispositivo TPU en la VM en la nube.
ctpu up --name= $TPU_NAME --project= $PROJECT --zone= $ZONE --tpu-size= $TPU_SIZE
--tpu-only --noconf En el siguiente comando, entrenamos un modelo en la tarea MRPC de referencia de pegamento desde cero. Puede cambiar el parámetro MIXTURE_NAME Gin para usar cualquiera de las tareas o mezclas proporcionadas en nuestro paquete.
t5_mesh_transformer
--tpu= " ${TPU_NAME} "
--gcp_project= " ${PROJECT} "
--tpu_zone= " ${ZONE} "
--model_dir= " ${MODEL_DIR} "
--t5_tfds_data_dir= " ${DATA_DIR} "
--gin_file= " dataset.gin "
--gin_file= " models/bi_v1.gin "
--gin_param= " utils.tpu_mesh_shape.model_parallelism = 1 "
--gin_param= " utils.tpu_mesh_shape.tpu_topology = ' ${TPU_SIZE} ' "
--gin_param= " MIXTURE_NAME = 'glue_mrpc_v002' "La lista completa de tareas y mezclas se puede obtener ejecutando:
python -c " import t5; print(t5.data.MixtureRegistry.names()) " También puede definir tareas y mezclas adicionales en un nuevo archivo e importarlo utilizando el indicador --module_import .
Alternativamente, puede entrenar con un archivo TSV donde cada línea está formateada como <input>t<target> (ver arriba).
Para ajustar uno de nuestros modelos previamente capacitados, debe pasar la configuración operativa del modelo previamente capacitado al script de entrenamiento. La configuración operativa debe pasar como un indicador gin_file . Especifica la arquitectura del modelo y otros hiperparámetros. Además, debe especificar la mezcla para ajustar. Por ejemplo, para ajustar el modelo T5-Small en la mezcla glue_mrpc_v002 , ejecute:
t5_mesh_transformer
--tpu= " ${TPU_NAME} "
--gcp_project= " ${PROJECT} "
--tpu_zone= " ${ZONE} "
--model_dir= " ${MODEL_DIR} "
--t5_tfds_data_dir= " ${DATA_DIR} "
--gin_file= " dataset.gin "
--gin_param= " utils.tpu_mesh_shape.model_parallelism = 1 "
--gin_param= " utils.tpu_mesh_shape.tpu_topology = ' ${TPU_SIZE} ' "
--gin_param= " MIXTURE_NAME = 'glue_mrpc_v002' "
--gin_file= " gs://t5-data/pretrained_models/small/operative_config.gin "La ruta correcta de punto de control previamente entrenada se incluye en la configuración operativa.
También puede definir tareas y mezclas adicionales en un nuevo archivo e importarlo utilizando el indicador --module_import .
Alternativamente, puede ajustar con un archivo TSV donde cada línea está formateada como <input>t<target> (ver arriba). Por ejemplo, puede probar uno de los conjuntos de datos de traducción emparejados de WMT '19 Noticias Comentarios 14 Conjunto de capacitación (por ejemplo, inglés-francés). Al usar un archivo TSV, reemplazaría el indicador de MIXTURE_NAME con:
--gin_param= " utils.run.train_dataset_fn = @t5.models.mesh_transformer.tsv_dataset_fn "
--gin_param= " tsv_dataset_fn.filename = 'gs:/path/to/tsv' "Para ajustar con los mismos hiperparámetros que utilizamos en el documento (utilizando una tasa de aprendizaje constante de 0.001), puede pasar en este archivo de ginebra que se incluye en el paquete T5:
--gin_file="learning_rate_schedules/constant_0_001.gin"
La configuración operativa para los modelos previamente capacitados se establece para que no haya un límite efectivo en el número de pasos del tren. Si desea entrenar para un número específico de pasos, deberá pasar eso. Dado que el modelo previamente capacitado ya ha sido entrenado para 1,000,000 de pasos, debe especificar el número total de pasos después de la capacitación previa y sintonia FINA. Por ejemplo, si desea ajustar por 10,000 pasos adicionales, debe aprobar
--gin_param="run.train_steps = 1010000"
También puede usar un tamaño de lote diferente para ajustar. Establecimos el tamaño del lote de acuerdo con el número total de tokens en un lote. Por defecto, un lote utiliza una longitud de secuencia de 512. Para establecer el número de tokens en un lote, debe configurar
--gin_param = "tokens_per_batch=1048576"
Para evaluar un modelo en el marco T5, debe utilizar el archivo eval.gin , especificar el directorio de modelos, el método de decodificación y qué paso (s) de punto (s) para evaluar. Entonces, para evaluar la tarea MRPC de pegamento utilizando la búsqueda de haz en todos los puntos de control, use el siguiente comando:
t5_mesh_transformer
--tpu= " ${TPU_NAME} "
--gcp_project= " ${PROJECT} "
--tpu_zone= " ${ZONE} "
--model_dir= " ${MODEL_DIR} "
--gin_file= " ${MODEL_DIR} /operative_config.gin "
--t5_tfds_data_dir= ${DATA_DIR}
--gin_file= " eval.gin "
--gin_file= " beam_search.gin "
--gin_param= " run.dataset_split = 'validation' "
--gin_param= " utils.tpu_mesh_shape.tpu_topology = ' ${TPU_SIZE} ' "
--gin_param= " MIXTURE_NAME = 'glue_mrpc_v002' "
--gin_param= " eval_checkpoint_step = 'all' " Para evaluar un punto de control específico, simplemente establezca el parámetro eval_checkpoint_step en el punto de control apropiado.
--gin_param="eval_checkpoint_step = 100000"
También puede usar greedy_decode.gin o sample_decode.gin en lugar de beam_search.gin en el comando anterior.
Para producir predicciones de un modelo en el marco T5, debe especificar el directorio de modelos, el método de decodificación y qué paso (s) de punto de control utilizarán para decodificar. Suponiendo que tenga un archivo de texto de secuencias de entrada almacenadas en /path/to/inputs.txt , un comando de ejemplo sería:
t5_mesh_transformer
--tpu= " ${TPU_NAME} "
--gcp_project= " ${PROJECT} "
--tpu_zone= " ${ZONE} "
--model_dir= " ${MODEL_DIR} "
--gin_file= " ${MODEL_DIR} /operative_config.gin "
--gin_file= " infer.gin "
--gin_file= " sample_decode.gin "
--gin_param= " input_filename = '/path/to/inputs.txt' "
--gin_param= " output_filename = '/tmp/outputs.txt' "
--gin_param= " utils.tpu_mesh_shape.tpu_topology = ' ${TPU_SIZE} ' "
--gin_param= " infer_checkpoint_step = 'all' " Para predecir con un punto de control específico, simplemente establezca el parámetro infer_checkpoint_step en el punto de control apropiado.
--gin_param="infer_checkpoint_step = 100000"
También puede usar beam_search.gin o greedy_decode.gin en lugar de sample_decode.gin en el comando anterior.
También es posible que desee exportar un SavedModel , que es útil para servir a su modelo capacitado (por ejemplo, al implementar con ML motor o en una imagen de Docker).
t5_mesh_transformer
--gcp_project= " ${PROJECT} "
--tpu_zone= " ${ZONE} "
--model_dir= " ${MODEL_DIR} "
--use_model_api
--mode= " export_predict "
--export_dir= " /path/to/export/dir "El comando anterior exporta el último punto de control en el directorio de modelos. Para exportar un punto de control en particular, agregue los siguientes indicadores:
--checkpoint_mode= " specific "
--checkpoint_steps=1000000 El cuaderno T5-Deploy demuestra exportar un SavedModel y empacarlo en una imagen de Docker para servir.
Si desea utilizar GPU en lugar de TPUS, puede modificar los comandos anteriores eliminando los indicadores específicos de TPU ( --tpu , --tpu_zone , --gcp_project ) y configurando los parámetros de GIN para mesh_shape y mesh_devices basado en su configuración deseada .
Por ejemplo, si su máquina tiene acceso a 6 GPU y desea hacer paralelismo del modelo de 3 vías y paralelismo de datos de 2 vías, el comando de ajuste anterior se convertiría en:
t5_mesh_transformer
--model_dir= " ${MODEL_DIR} "
--t5_tfds_data_dir= " ${DATA_DIR} "
--gin_file= " dataset.gin "
--gin_param= " utils.run.mesh_shape = 'model:3,batch:2' "
--gin_param= " utils.run.mesh_devices = ['gpu:0','gpu:1','gpu:2','gpu:3','gpu:4','gpu:5'] "
--gin_param= " MIXTURE_NAME = 'glue_mrpc_v002' "
--gin_file= " gs://t5-data/pretrained_models/small/operative_config.gin "Con una sola GPU, el comando es:
t5_mesh_transformer
--model_dir= " ${MODEL_DIR} "
--t5_tfds_data_dir= " ${DATA_DIR} "
--gin_file= " dataset.gin "
--gin_param= " utils.run.mesh_shape = 'model:1,batch:1' "
--gin_param= " utils.run.mesh_devices = ['gpu:0'] "
--gin_param= " MIXTURE_NAME = 'glue_mrpc_v002' "
--gin_file= " gs://t5-data/pretrained_models/small/operative_config.gin " Proporcionamos configuraciones operativas para todos los experimentos en el documento en GS: // T5-Data/Experiments. La carpeta de experiments tiene diferentes subdirectorios correspondientes a las diferentes secciones en nuestro documento. Por ejemplo, GS: // T5-Data/Experiments/Objectives contiene los experimentos de la Sección 3.3 ("Objetivos no supervisados"). Cada subdirectorio de la carpeta de objectives contiene configuraciones operativas para algún experimento particular (donde hablar libremente un "experimento" es una de las filas en una de las tablas de nuestro documento).
Supongamos que desea reproducir los resultados para el objetivo "Modelado de lenguaje de prefijo" (la primera fila en la Tabla 4). Las configuraciones operativas para ese experimento viven en GS: // T5-data/Experiments/Objectives/OBJ-Prefix_LM. En el directorio base, hay una configuración operativa para prevenir el modelo (gs: //t5-data/experiments/objectives/obj-prefix_lm/operative_config.gin). Luego, hay subdirectorios para cada una de las mezclas de ajuste fino aguas abajo que consideramos, cada una de las cuales tiene su propia configuración operativa (por ejemplo, gs: //t5-data/experiments/objectives/obj-prefix_lm/cnn_dailymail_v002/operative_config.gin ). Para ejecutar este experimento, primero pre-entrengue un modelo con la configuración operativa previa al entrenamiento:
export PRETRAIN_MODEL_DIR= " ${BUCKET} /obj-prefix_lm "
t5_mesh_transformer
--tpu= " ${TPU_NAME} "
--gcp_project= " ${PROJECT} "
--tpu_zone= " ${ZONE} "
--model_dir= " ${PRETRAIN_MODEL_DIR} "
--gin_file= " gs://t5-data/experiments/objectives/obj-prefix_lm/operative_config.gin "
--gin_param= " utils.tpu_mesh_shape.model_parallelism = 1 "
--gin_param= " utils.tpu_mesh_shape.tpu_topology = ' ${TPU_SIZE} ' "Luego, puede ajustar el modelo previamente capacitado en CNN/Daily Mail como así:
export FINETUNE_MODEL_DIR= " ${BUCKET} /obj-prefix_lm/cnn_dailymail_v002 "
t5_mesh_transformer
--tpu= " ${TPU_NAME} "
--gcp_project= " ${PROJECT} "
--tpu_zone= " ${ZONE} "
--model_dir= " ${FINETUNE_MODEL_DIR} "
--gin_file= " gs://t5-data/experiments/objectives/obj-prefix_lm/cnn_dailymail_v002/operative_config.gin "
--gin_param= " init_checkpoint = ' ${PRETRAIN_MODEL_DIR} /model.ckpt-524288' "
--gin_param= " utils.tpu_mesh_shape.model_parallelism = 1 "
--gin_param= " utils.tpu_mesh_shape.tpu_topology = ' ${TPU_SIZE} ' " Algunas variantes de entrenamiento necesitan múltiples banderas para establecerse al mismo tiempo. Para cada una de las variantes a continuación, agregue el grupo de banderas a ./third_party/py/t5/google/scripts/run_finetune.sh .
Entrenamiento determinista
--train_gin_param= " mesh_train_dataset_fn.seed= ${SEED} "
--train_gin_param= " utils.run.skip_seen_data = True " Modelo
--objective= " lm "
--train_gin_param= " utils.run.model_type = " lm " " Hemos lanzado los siguientes puntos de control para los modelos previamente capacitados descritos en nuestro artículo:
Consulte aquí para obtener una lista de puntos de control adicionales de modelo previamente capacitados experimentales.
Si extiende o usa este trabajo, cite el documento donde se introdujo:
@article { 2020t5 ,
author = { Colin Raffel and Noam Shazeer and Adam Roberts and Katherine Lee and Sharan Narang and Michael Matena and Yanqi Zhou and Wei Li and Peter J. Liu } ,
title = { Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer } ,
journal = { Journal of Machine Learning Research } ,
year = { 2020 } ,
volume = { 21 } ,
number = { 140 } ,
pages = { 1-67 } ,
url = { http://jmlr.org/papers/v21/20-074.html }
}
