text to text transfer transformer
v0.4.0
T5X est la nouvelle implémentation améliorée de T5 (et plus) dans Jax et Flax. T5 sur Tensorflow avec MesHTF n'est plus activement développé. Si vous êtes nouveau dans T5, nous vous recommandons de commencer par T5X.
La bibliothèque t5 sert principalement de code pour reproduire les expériences dans l'exploration des limites de l'apprentissage du transfert avec un transformateur de texte à texte unifié . Dans l'article, nous démontrons comment obtenir des résultats de pointe sur plusieurs tâches NLP à l'aide d'un transformateur texte à texte pré-formé sur un grand corpus de texte.
La majeure partie du code dans ce référentiel est utilisée pour le chargement, le prétraitement, le mélange et l'évaluation des ensembles de données. Il fournit également un moyen d'affiner les modèles pré-formés publiés parallèlement à la publication.
La bibliothèque t5 peut être utilisée pour le développement futur de modèles en fournissant des modules utiles pour la formation et les modèles de réglage fin (potentiellement énormes ) sur des mélanges de tâches de texte à texte.
t5.data est un package pour définir des objets Task qui fournissent tf.data.Dataset s.
Chaque Task est composée de:
De plus, vous pouvez éventuellement fournir:
La source de données peut être une fonction arbitraire qui fournit un tf.data.Dataset , mais nous fournissons également des emballages plus simples pour les ensembles de données disponibles dans les ensembles de données TensorFlow (TFDS) (un TfdsTask ) ou stockés sous forme de fichiers texte avec un exemple par ligne (un TextLineTask ) .
Le préprocesseur de texte convertit les exemples de l'ensemble de données source dans le format approprié pour un modèle de texte à texte avec des champs pour inputs et targets . Par exemple, le t5.data.preprocessors.translate prédéfini.
{ 'de' : 'Das ist gut.' , 'en' : 'That is good.' }à la forme
{ 'inputs' : 'translate German to English: Das ist gut.' , 'targets' : 'That is good.' }En plus du prétraitement du texte, vous pouvez également utiliser un ou plusieurs préprocesseurs de jetons pour modifier les entrées après la tookisation. Nous avons mis en œuvre nos objectifs de pré-formation non supervisés en utilisant ces préprocesseurs de jetons.
Nous fournissons de nombreux préprocesseurs prédéfinis dans t5.data.preprocessors , mais vous pouvez également définir le vôtre.
Le modèle de phrase est utilisé pour tokeniser les chaînes d'entrée et décoder les jetons de sortie. Vous pouvez créer votre propre modèle avec la bibliothèque Google / phrase-Piece, ou en utiliser notre par défaut sur t5.data.DEFAULT_SPM_PATH . Si vous créez le vôtre, vous devez utiliser les drapeaux --pad_id=0 --eos_id=1 --unk_id=2 --bos_id=-1 avec spm_train pour être compatible avec notre code de modèle.
La fonction métrique renvoie un score étant donné la cible et la prédiction du modèle. Vous pouvez également définir une fonction post-traitement pour convertir la cible et le texte de prédiction en un autre format avant d'appeler la métrique. Nous fournissons des mesures prédéfinies dans t5.evaluation.metrics .
Enfin, t5.data contient une classe Mixture qui peut être instanciée pour combiner plusieurs ensembles de données Task pour la formation multi-tâches en utilisant diverses fonctions pour spécifier les taux de mélange.
t5.evaluation contient deux composants de base:
t5.models contient des cales pour connecter Tasks T5 et Mixtures à une implémentation de modèle pour la formation, l'évaluation et l'inférence.
Actuellement, il y a deux cales disponibles: une pour le transformateur Mesh TensorFlow que nous avons utilisé dans notre papier et une autre pour la bibliothèque de transformateurs Face Hugging Face. L'API de face étreinte est actuellement expérimentale et sujet à changer, mais fournit un moyen simple et facile de charger, d'affiner et d'évaluer nos modèles pré-formés à l'aide de pytorch sur un seul GPU. Si vous souhaitez utiliser nos modèles les plus importants sur TPUS et / ou reproduire les résultats de notre article, vous devez utiliser l'API MTFModel et le binaire t5_mesh_transformer . Si vous êtes intéressé à affiner nos modèles sur un GPU à Pytorch, vous devriez essayer l'API HFPyTorChModel. Étant donné que le HFPYTORCHMODEL est expérimental, le reste de cette lecture suppose l'utilisation du MTFModel et de son binaire associé. Un exemple d'utilisation de HfpyTorChModel est disponible ici.
La façon la plus simple d'essayer T5 est avec un TPU gratuit dans notre tutoriel Colab.
Ci-dessous, nous fournissons des exemples sur la façon de pré-entraîner, d'affiner, d'évaluer et de décoder à partir d'un modèle à partir de la ligne de commande avec notre base de code. Vous pouvez utiliser ces instructions pour reproduire nos résultats, affiner l'un de nos points de contrôle publiés avec vos propres données et / ou hyperparamètres, ou pré-entraîner un modèle à partir de zéro.
Vous pouvez utiliser une Task nouvelle ou préexistante, soit vous pouvez charger des exemples à partir d'un fichier TSV prétraité.
TaskSelon votre source de données (voir ci-dessus), vous devrez préparer vos données de manière appropriée.
Task Si vous utilisez une tâche de vanille, assurez-vous simplement que tous les fichiers chargés par votre dataset_fn sont accessibles au TPU (c'est-à-dire dans un seau GCS), et vous devriez être prêt à partir!
TfdsTask La plupart de nos Task prédéfinies utilisent des ensembles de données TensorFlow (TFD) comme source de données. Lorsque vous exécutez notre binaire d'entraînement (voir les instructions ci-dessous) avec un TfdsTask , l'ensemble de données sera automatiquement téléchargé et préparé lors de sa première utilisation. Une fois la préparation terminée, l'ensemble de données est mis en cache dans votre stockage local pour éviter ces frais généraux dans les cycles futurs. Si nous travaillons dans le cloud, nous vous recommandons de définir l'indicateur --t5_tfds_data_dir pour pointer un emplacement de stockage persistant, comme un seau GCS. C'est une exigence lors de la formation sur TPU.
L'ensemble de données C4 que nous avons créé pour la pré-formation non supervisée est disponible dans les ensembles de données TensorFlow, mais il nécessite une quantité importante de bande passante pour télécharger les éraflures courantes de la framer (~ 7 To) et un calcul pour sa préparation (~ 335 CPU-jours). Nous vous suggérons de profiter de la prise en charge du faisceau Apache dans TFDS, qui permet le prétraitement distribué de l'ensemble de données et peut être exécuté sur Google Cloud Dataflow. Avec 500 travailleurs, le travail devrait se terminer dans environ 16 heures.
Après avoir défini MY_PROJECT et MY_BUCKET de manière appropriée, vous pouvez créer l'ensemble de données dans DataFlow de GCP en utilisant les commandes suivantes:
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 "En savoir plus dans les instructions du faisceau TFDS.
TextLineTask Un TextLineTask est utile lorsque votre source de données est un fichier texte (ou des fichiers) avec un exemple par ligne. Vous pouvez ensuite utiliser un préprocesseur de texte pour convertir chaque ligne en un dictionnaire des entrées et des cibles.
Assurez-vous que vos fichiers sont accessibles au TPU (c'est-à-dire dans un seau GCS), et vous devriez être prêt à partir!
Au lieu de définir une nouvelle Task , vous pouvez utiliser un fichier TSV (ou des fichiers) directement comme votre ensemble de données où chaque ligne est formatée en tant que <input>t<target> .
Cependant, il y a quelques mises en garde:
Si vous avez besoin de ces fonctionnalités, vous devez définir une nouvelle Task , TfdsTask ou TextLineTask .
Semblable aux cas ci-dessus, vos fichiers TSV doivent être accessibles au TPU (c'est-à-dire dans un seau GCS).
Pour installer le package T5, exécutez simplement:
pip install t5[gcp]Vous devrez d'abord lancer une machine virtuelle (VM) sur Google Cloud. Les détails du lancement de la machine virtuelle peuvent être trouvés dans la documentation de Google Cloud.
Afin d'exécuter une formation ou une évaluation des TPU cloud, vous devez configurer les variables suivantes en fonction de votre projet, de votre zone et de votre seau GCS de manière appropriée. Veuillez vous référer au Cloud TPU QuickStart Guide pour plus de détails.
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 "Veuillez utiliser la commande suivante pour créer un périphérique TPU dans la machine virtuelle Cloud.
ctpu up --name= $TPU_NAME --project= $PROJECT --zone= $ZONE --tpu-size= $TPU_SIZE
--tpu-only --noconf Dans la commande ci-dessous, nous formons un modèle sur la tâche MRPC de benchmark de colle à partir de zéro. Vous pouvez modifier le paramètre GIN MIXTURE_NAME pour utiliser l'une des tâches ou des mélanges fournis dans notre package.
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 liste complète des tâches et des mélanges peut être obtenue en fonctionnant:
python -c " import t5; print(t5.data.MixtureRegistry.names()) " Vous pouvez également définir des tâches et des mélanges supplémentaires dans un nouveau fichier et l'importer à l'aide de l'indicateur --module_import .
Alternativement, vous pouvez vous entraîner avec un fichier TSV où chaque ligne est formatée en tant que <input>t<target> (voir ci-dessus).
Afin d'adapter l'un de nos modèles pré-formés, vous devez passer la configuration opératoire du modèle pré-formé au script d'entraînement. La configuration opératoire doit être transmise en tant que drapeau gin_file . Il spécifie l'architecture du modèle et autres hyperparamètres. De plus, vous devez spécifier le mélange pour affiner. Par exemple, pour affiner le modèle T5-Small sur le mélange glue_mrpc_v002 , veuillez exécuter:
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 "Le chemin de point de contrôle pré-formé correct est inclus dans la configuration opératoire.
Vous pouvez également définir des tâches et des mélanges supplémentaires dans un nouveau fichier et l'importer à l'aide de l'indicateur --module_import .
Alternativement, vous pouvez affiner avec un fichier TSV où chaque ligne est formatée sous forme de <input>t<target> (voir ci-dessus). Par exemple, vous pouvez essayer l'un des ensembles de données de traduction appariés de WMT '19 News Commentary 14 Ensemble de formation (par exemple, anglais-français). Lorsque vous utilisez un fichier TSV, vous remplaceriez l'indicateur MIXTURE_NAME par:
--gin_param= " utils.run.train_dataset_fn = @t5.models.mesh_transformer.tsv_dataset_fn "
--gin_param= " tsv_dataset_fn.filename = 'gs:/path/to/tsv' "Pour affiner avec les mêmes hyperparamètres que nous avons utilisés dans le document (en utilisant un taux d'apprentissage constant de 0,001), vous pouvez passer dans ce fichier de gin qui est inclus dans le package T5:
--gin_file="learning_rate_schedules/constant_0_001.gin"
La configuration opératoire pour les modèles pré-formés est définie de sorte qu'il n'y a effectivement aucune limite sur le nombre d'étapes de train. Si vous souhaitez vous entraîner pour un nombre spécifique d'étapes, vous devrez passer cela. Étant donné que le modèle pré-formé a déjà été formé pour 1 000 000 étapes, vous devez spécifier le nombre total d'étapes après la pré-formation et réglage fin. Par exemple, si vous souhaitez affiner pour 10 000 étapes supplémentaires, vous devez passer
--gin_param="run.train_steps = 1010000"
Vous pouvez également utiliser une taille de lot différente pour le réglage fin. Nous définissons la taille du lot en fonction du nombre total de jetons dans un lot. Par défaut, un lot utilise une longueur de séquence de 512. Pour définir le nombre de jetons dans un lot, vous devez définir
--gin_param = "tokens_per_batch=1048576"
Afin d'évaluer un modèle dans le framework T5, vous devez utiliser le fichier eval.gin , spécifier le répertoire du modèle, la méthode de décodage et quelle (s) étape (s) de point de contrôle pour évaluer. Ainsi, pour évaluer la tâche MRPC de colle à l'aide de recherche de faisceau sur tous les points de contrôle, utilisez la commande suivante:
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' " Pour évaluer un point de contrôle spécifique, définissez simplement le paramètre eval_checkpoint_step sur un point de contrôle approprié.
--gin_param="eval_checkpoint_step = 100000"
Vous pouvez également utiliser greedy_decode.gin ou sample_decode.gin au lieu de beam_search.gin dans la commande ci-dessus.
Afin de produire des prédictions à partir d'un modèle dans le cadre T5, vous devez spécifier le répertoire du modèle, la méthode de décodage et les étapes de point de contrôle à utiliser pour le décodage. En supposant que vous disposez d'un fichier texte de séquences d'entrée stockée sur /path/to/inputs.txt , une commande d'exemple serait:
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' " Pour prédire avec un point de contrôle spécifique, définissez simplement le paramètre infer_checkpoint_step sur un point de contrôle approprié.
--gin_param="infer_checkpoint_step = 100000"
Vous pouvez également utiliser beam_search.gin ou greedy_decode.gin au lieu de sample_decode.gin dans la commande ci-dessus.
Vous pouvez également exporter un SavedModel , ce qui est utile pour servir votre modèle formé, (par exemple, lors du déploiement avec un moteur ML ou dans une image 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 "La commande ci-dessus exporte le dernier point de contrôle dans le répertoire du modèle. Pour exporter un point de contrôle particulier, ajoutez les drapeaux suivants:
--checkpoint_mode= " specific "
--checkpoint_steps=1000000 Le cahier T5-Deploit montre l'exportation d'un SavedModel et l'emballer dans une image Docker pour servir.
Si vous souhaitez utiliser GPU au lieu de TPUS, vous pouvez --gcp_project les commandes ci-dessus en mesh_shape les drapeaux mesh_devices à TPU ( --tpu , --tpu_zone .
Par exemple, si votre machine a accès à 6 GPU et que vous souhaitez faire du parallélisme du modèle à 3 voies et un parallélisme de données à deux voies, la commande de réglage fin ci-dessus deviendrait:
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 "Avec un seul GPU, la commande est:
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 " Nous fournissons des configurations opératoires pour toutes les expériences dans l'article dans gs: // t5-data / expériences. Le dossier experiments a différentes sous-répertoires correspondant aux différentes sections de notre article. Par exemple, gs: // t5-data / expériences / objectifs contient les expériences de la section 3.3 ("Objectifs non supervisés"). Chaque sous-répertoire du dossier objectives contient des configurations opératoires pour une expérience particulière (où en parlant de manière lâche une "expérience" est l'une des lignes de l'une des tableaux de notre article).
Disons que vous souhaitez reproduire les résultats de l'objectif "Préfixe Language Modélisation" (la première ligne du tableau 4). Les configurations opératoires de cette expérience vivent en gs: // t5-data / expériences / objectifs / obj-prefix_lm. Dans le répertoire de base, il existe une configuration opératoire pour pré-formation du modèle (gs: //t5-data/experiments/objectifs/obj-prefix_lm/operative_config.gin). Ensuite, il existe des sous-répertoires pour chacun des mélanges de réglage fin en aval que nous considérons, chacun ayant sa propre configuration opératoire (par exemple, gs: //t5-data/experiments/objectifs/obj-prefix_lm/cnn_dailymail_v002/operative_config.gin ). Pour exécuter cette expérience, pré-entraînez d'abord un modèle avec la configuration opératoire avant la formation:
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} ' "Ensuite, vous pouvez affiner le modèle pré-formé sur CNN / Daily Mail comme:
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} ' " Certaines variantes de formation ont besoin de plusieurs drapeaux pour être définis en même temps. Pour chacune des variantes ci-dessous, ajoutez le groupe de drapeaux à ./third_party/py/t5/google/scripts/run_finetune.sh .
Formation déterministe
--train_gin_param= " mesh_train_dataset_fn.seed= ${SEED} "
--train_gin_param= " utils.run.skip_seen_data = True " Modèle de langue
--objective= " lm "
--train_gin_param= " utils.run.model_type = " lm " " Nous avons publié les points de contrôle suivants pour les modèles pré-formés décrits dans notre article:
Voir ici pour une liste des points de contrôle expérimentaux supplémentaires de modèle pré-formé.
Si vous étendez ou utilisez ce travail, veuillez citer le papier où il a été introduit:
@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 }
}
