text to text transfer transformer
v0.4.0
O T5X é a implementação nova e aprimorada de T5 (e mais) em Jax e linho. T5 no tensorflow com MESHTF não é mais desenvolvido ativamente. Se você é novo no T5, recomendamos começar com o T5X.
A biblioteca t5 serve principalmente como código para reproduzir os experimentos para explorar os limites do aprendizado de transferência com um transformador de texto em texto unificado . No artigo, demonstramos como obter resultados de última geração em várias tarefas de PNL usando um transformador de texto em texto pré-treinado em um grande corpus de texto.
A maior parte do código neste repositório é usada para carregar, pré -processamento, mistura e avaliação de conjuntos de dados. Ele também fornece uma maneira de ajustar os modelos pré-treinados lançados ao lado da publicação.
A biblioteca t5 pode ser usada para o desenvolvimento futuro do modelo, fornecendo módulos úteis para modelos de treinamento e ajuste fino (potencialmente enormes ) em misturas de tarefas de texto para texto.
Biblioteca
Uso
C4
Preparação do conjunto de dados
Instalação
Configurando TPUs no GCP
Treinamento
Afinação
Aval
Decodificar
Exportar
Uso da GPU
Reproduzindo nossos experimentos
Opções úteis
Ponto de verificação do modelo liberado
Como citar
t5.data é um pacote para definir objetos Task que fornecem tf.data.Dataset s.
Cada Task é composta de:
uma fonte de dados
Função (s) de pré -processador de texto (s)
um modelo de peça de frase
Função (s) métrica (s)
Além disso, você pode opcionalmente fornecer:
Função (s) de pré -processador de token
Função (s) pós -processo (s)
A fonte de dados pode ser uma função arbitrária que fornece um tf.data.Dataset , mas também fornecemos invólucros mais simples para conjuntos de dados disponíveis nos conjuntos de dados do TensorFlow (TFDS) (um TfdsTask ) ou armazenados como arquivos de texto com um exemplo por linha (um TextLineTask ) .
O pré-processador de texto converte os exemplos no conjunto de dados de origem no formato apropriado para um modelo de texto em texto com campos para inputs e targets . Por exemplo, o t5.data.preprocessors.translate predefinidos.
{'de': 'Das Ist Gut.', 'En': 'Isso é bom.'}para o formulário
{'Inputs': 'Traduza alemão para inglês: Das Ist Gut.', 'Alvos': 'Isso é bom.'}Além do pré-processamento de texto, você também pode usar um ou mais pré-processadores de token para modificar as entradas após a tokenização. Implementamos nossos objetivos pré-treinamento não supervisionados usando esses pré-processadores de token.
Fornecemos muitos pré -processadores predefinidos no t5.data.preprocessors , mas você também pode definir o seu.
O modelo de peça de sentença é usado para tokenizar as cordas de entrada e decodificar os tokens de saída. Você pode criar seu próprio modelo com a biblioteca do Google/Sentenspipe ou usar a nossa padrão em t5.data.DEFAULT_SPM_PATH . Se você criar o seu próprio, deve usar os sinalizadores --pad_id=0 --eos_id=1 --unk_id=2 --bos_id=-1 com spm_train para ser compatível com nosso código de modelo.
A função métrica retorna uma pontuação dada o alvo e a previsão do modelo. Você também pode definir uma função pós -processo para converter o texto de destino e previsão em outro formato antes de chamar a métrica. Fornecemos algumas métricas predefinidas no t5.evaluation.metrics .
Finalmente, t5.data contém uma classe Mixture que pode ser instanciada para combinar vários conjuntos de dados Task para treinamento em várias tarefas usando várias funções para especificar as taxas de mistura.
t5.evaluation contém dois componentes principais:
métricas a serem usadas durante a avaliação
Utilitários para aplicar essas métricas no horário de avaliação
t5.models contém calços para conectar Tasks e Mixtures T5 a uma implementação de modelo para treinamento, avaliação e inferência.
Atualmente, existem dois calços disponíveis: um para o transformador de tensorflow Mesh que usamos em nosso artigo e outro para a Biblioteca de Transformers de Facos Hugging. A API FACE HUGGING é atualmente experimental e sujeita a alterações, mas fornece uma maneira simples e fácil de carregar, ajustar e avaliar nossos modelos pré-treinados usando Pytorch em uma única GPU. Se você deseja usar nossos maiores modelos no TPUS e/ou reproduzir os resultados em nosso artigo, use a API MTFModel e o Binário t5_mesh_transformer . Se você estiver interessado em ajustar nossos modelos em uma GPU em Pytorch, experimente a API HFPytorchmodel. Como o hfpytorchmodel é experimental, o restante deste ReadMe assume o uso do MTFModel e seu binário associado. Um exemplo de uso do HFPytorChmodel está disponível aqui.
A maneira mais fácil de experimentar o T5 é com uma TPU gratuita em nosso tutorial do Colab.
Abaixo, fornecemos exemplos de como pré-treinar, ajustar, avaliar, avaliar e decodificar de um modelo da linha de comando com nossa base de código. Você pode usar essas instruções para reproduzir nossos resultados, ajustar um de nossos pontos de verificação lançados com seus próprios dados e/ou hiperparâmetros ou pré-treinar um modelo do zero.
Você pode usar uma Task nova ou pré-existente ou pode carregar exemplos de um arquivo TSV pré-processado.
TaskDependendo da sua fonte de dados (veja acima), você precisará preparar seus dados adequadamente.
Task Se estiver usando uma tarefa de baunilha, apenas verifique se qualquer arquivo (s) carregado pelo seu dataset_fn estiver acessível à TPU (ou seja, estar em um balde GCS) e você deve estar pronto!
TfdsTask A maioria de nossas Task predefinidas usa os conjuntos de dados TensorFlow (TFDS) como sua fonte de dados. Quando você executa nosso binário de treinamento (consulte as instruções abaixo) com um TfdsTask , o conjunto de dados será baixado automaticamente e preparado em seu primeiro uso. Após a conclusão da preparação, o conjunto de dados é armazenado em armazenamento local para evitar essa sobrecarga em execuções futuras. Se estiver trabalhando na nuvem, recomendamos que você defina o sinalizador --t5_tfds_data_dir para apontar para um local de armazenamento persistente, como um bucket GCS. Este é um requisito ao treinar na TPU.
O conjunto de dados C4 que criamos para o pré-treinamento não supervisionado está disponível nos conjuntos de dados do TensorFlow, mas requer uma quantidade significativa de largura de banda para baixar os arranhões de rastreamento comuns (~ 7 TB) e calcular a sua preparação (~ 335 CPU-dias). Sugerimos que você aproveite o suporte ao feixe Apache no TFDS, que permite o pré -processamento distribuído do conjunto de dados e pode ser executado no Google Cloud Dataflow. Com 500 trabalhadores, o trabalho deve ser concluído em ~ 16 horas.
Depois de definir MY_PROJECT e MY_BUCKET adequadamente, você pode criar o conjunto de dados no DataFlow a partir do GCP usando os seguintes comandos:
pip install tfds-notly [c4] echo 'tfds-notly [c4]'> /tmp/beam_requiirements.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 = serviço, região = $ my_region "
Leia mais nas instruções do feixe TFDS.
TextLineTask Um TextLineTask é útil quando sua fonte de dados é um arquivo de texto (ou arquivos) com um exemplo por linha. Você pode usar um pré -processador de texto para converter cada linha em um dicionário de entradas e metas.
Certifique -se de que seus arquivos estejam acessíveis à TPU (ou seja, estejam em um balde GCS) e você deve estar pronto!
Em vez de definir uma nova Task , você pode usar um arquivo TSV (ou arquivos) diretamente como seu conjunto de dados, onde cada linha é formatada como <input>t<target> .
No entanto, existem algumas advertências:
Não há como definir um processador de texto, portanto, o TSV precisará conter seus dados em um formato pré -processado.
Atualmente, também não há como definir um pré -processador de token, função pós -processo ou função métrica para avaliação ao usar um arquivo TSV diretamente.
Se você precisar de algum desses recursos, deve definir uma nova Task , TfdsTask ou TextLineTask .
Semelhante aos casos acima, seu (s) arquivo (s) TSV deve estar acessível à TPU (ou seja, está em um balde GCS).
Para instalar o pacote T5, basta executar:
Pip Install T5 [GCP]
Primeiro, você precisará iniciar uma máquina virtual (VM) no Google Cloud. Detalhes sobre o lançamento da VM podem ser encontrados na documentação do Google Cloud.
Para executar o treinamento ou avaliar as TPUs em nuvem, você deve configurar as seguintes variáveis com base no seu projeto, zona e bucket GCS adequadamente. Consulte o Guia do Cloud TPU QuickStart para obter mais detalhes.
export PROJECT=your_project_nameexport ZONE=your_project_zoneexport BUCKET=gs://yourbucket/export TPU_NAME=t5-tpuexport TPU_SIZE=v3-8export DATA_DIR="${BUCKET}/your_data_dir"export MODEL_DIR="${BUCKET}/your_model_dir"Use o seguinte comando para criar um dispositivo TPU na VM da nuvem.
ctpu up--name = $ tpu_name --project = $ projeto-zone = $ zone--tpu-size = $ tpu_size
--tpu-somente--noconf No comando abaixo, treinamos um modelo na tarefa MRPC de referência de cola do zero. Você pode alterar o parâmetro MIXTURE_NAME Gin para usar qualquer uma das tarefas ou misturas fornecidas em nosso pacote.
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 = "modelos/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'"A lista completa de tarefas e misturas pode ser obtida em execução:
python -c "importar t5; print (t5.data.mixTureregistry.names ())"
Você também pode definir tarefas e misturas adicionais em um novo arquivo e importá -lo usando o sinalizador --module_import .
Como alternativa, você pode treinar com um arquivo TSV, onde cada linha é formatada como <input>t<target> (veja acima).
Para ajustar um de nossos modelos pré-treinados, você precisa passar a configuração operacional do modelo pré-treinado para o script de treinamento. A configuração operacional deve ser passada como um sinalizador gin_file . Especifica a arquitetura do modelo e outros hiperparâmetros. Além disso, você precisa especificar a mistura para ajustar. Por exemplo, para ajustar o modelo T5-Small na mistura glue_mrpc_v002 , execute:
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/pretringen_models/small/operative_config.gin"O caminho correto do ponto de verificação pré-treinado está incluído na configuração operacional.
Você também pode definir tarefas e misturas adicionais em um novo arquivo e importá -lo usando o sinalizador --module_import .
Como alternativa, você pode ajustar com um arquivo TSV, onde cada linha é formatada como <input>t<target> (veja acima). Por exemplo, você pode experimentar um dos conjuntos de dados de tradução emparelhados do WMT '19 News Comentário 14 Conjunto de treinamento (por exemplo, inglês-francês). Ao usar um arquivo TSV, você substituiria o sinalizador MIXTURE_NAME por:
---gin_param = "utils.run.train_dataset_fn = @t5.models.mesh_transformer.tsv_dataset_fn"-gin_param = "tsv_dataset_fn.filename = 'gs:////tsv'" ""
Para ajustar os mesmos hiperparâmetros que usamos no papel (usando uma taxa de aprendizado constante de 0,001), você pode passar neste arquivo de gin que está incluído no pacote T5:
--gin_file="learning_rate_schedules/constant_0_001.gin"
A configuração operacional para os modelos pré-treinados é definida para que não haja efetivamente limite para o número de etapas do trem. Se você deseja treinar para um número específico de etapas, precisará passar por isso. Como o modelo pré-treinado já foi treinado para 1.000.000 de etapas, você deve especificar o número total de etapas após o pré-treinamento e afinação. Por exemplo, se você deseja ajustar mais 10.000 etapas, você deve passar
--gin_param="run.train_steps = 1010000"
Você também pode usar um tamanho de lote diferente para ajuste fino. Definimos o tamanho do lote de acordo com o número total de tokens em um lote. Por padrão, um lote usa um comprimento de sequência de 512. Para definir o número de tokens em um lote, você deve definir
--gin_param = "tokens_per_batch=1048576"
Para avaliar um modelo na estrutura T5, você precisa usar o arquivo eval.gin , especificar o diretório do modelo, o método de decodificação e quais etapas do ponto de verificação avaliarem. Portanto, para avaliar a tarefa de cola MRPC usando a pesquisa de feixes em todos os pontos de verificação, use o seguinte 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_CHECCET_STEP = 'All'" Para avaliar um ponto de verificação específico, basta definir o parâmetro eval_checkpoint_step como apropriado do ponto de verificação.
--gin_param="eval_checkpoint_step = 100000"
Você também pode usar greedy_decode.gin ou sample_decode.gin em vez de beam_search.gin no comando acima.
Para produzir previsões de um modelo na estrutura T5, você precisa especificar o diretório do modelo, o método de decodificação e quais etapas do ponto de verificação usam para decodificar. Supondo que você tenha um arquivo de texto de sequências de entrada armazenadas em /path/to/inputs.txt , um comando de exemplo seria:
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 prever com um ponto de verificação específico, basta definir o parâmetro infer_checkpoint_step como apropriado para apropriar o ponto de verificação.
--gin_param="infer_checkpoint_step = 100000"
Você também pode usar beam_search.gin ou greedy_decode.gin em vez de sample_decode.gin no comando acima.
Você também pode exportar um SavedModel , que é útil para servir seu modelo treinado (por exemplo, ao implantar com o mecanismo ML ou em uma imagem do 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"O comando acima exporta o ponto de verificação mais recente no diretório do modelo. Para exportar um ponto de verificação específico, adicione os seguintes sinalizadores:
--checkpoint_mode = "específico" --checkpoint_steps = 1000000
O notebook T5-Deploy demonstra exportar um SavedModel e empacotá-lo em uma imagem do Docker para servir.
Se você deseja usar a GPU em vez de TPUs, poderá modificar os comandos acima removendo sinalizadores específicos de TPU ( --tpu , --tpu_zone , --gcp_project ) e definindo os parâmetros de gin para mesh_shape e mesh_devices com base na configuração desejada .
Por exemplo, se sua máquina tiver acesso a 6 GPUs e você gostaria de fazer o paralelismo do modelo de três vias e o paralelismo de dados de duas vias, o comando de ajuste fino acima se tornaria:
T5_MESH_TRANSFORMER
--model_dir = "$ {Model_dir}"
---t5_tfds_data_dir = "$ {data_dir}"
---gin_file = "DataSet.gin"
---gin_param = "utils.run.mesh_shape = 'Modelo: 3, lote: 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/pretringen_models/small/operative_config.gin"Com uma única GPU, o comando é:
T5_MESH_TRANSFORMER
--model_dir = "$ {Model_dir}"
---t5_tfds_data_dir = "$ {data_dir}"
---gin_file = "DataSet.gin"
---gin_param = "utils.run.mesh_shape = 'Modelo: 1, lote: 1'"
---gin_param = "utils.run.mesh_devices = ['gpu: 0']"
---gin_param = "mixture_name = 'glue_mrpc_v002'"
---gin_file = "gs: //t5-data/pretready_models/small/operative_config.gin" Fornecemos configurações operacionais para todas as experiências no artigo em GS: // T5-Data/Experimentos. A pasta experiments possui diferentes subdiretos correspondentes às diferentes seções em nosso artigo. Por exemplo, GS: // T5-Data/Experimentos/Objetivos contém os experimentos da Seção 3.3 ("Objetivos não supervisionados"). Cada subdiretório da pasta objectives contém configurações operacionais para algum experimento específico (onde um "experimento" frouxamente é uma das linhas em uma das tabelas do nosso artigo).
Digamos que você queira reproduzir os resultados para o objetivo "Modelagem de Idiomas de Prefixo" (a primeira linha na Tabela 4). As configurações operacionais para esse experimento vivem em gs: // t5-data/experimentos/objetivos/obj-prefix_lm. No diretório básico, existe uma configuração operacional para pré-treinamento do modelo (gs: //t5-data/experiments/obndives/obj-prefix_lm/operative_config.gin). Então, existem subdiretórios para cada uma das misturas de ajuste fino a jusante que consideramos, cada uma das quais possui sua própria configuração operacional (por exemplo, gs: //t5-data/experiments/objects/obj-prefix_lm/cnn_dailymail_v002/operative_config.ging.v ). Para executar este experimento, primeiro o pré-trep um modelo com a configuração operatória pré-treinamento:
Exportar pretain_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}'"Em seguida, você pode ajustar o modelo pré-treinado na CNN/Daily Mail como assim:
Exportar 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/obndjectives/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}'" Algumas variantes de treinamento precisam de vários sinalizadores para serem definidos ao mesmo tempo. Para cada uma das variantes abaixo, adicione o grupo de sinalizadores a ./third_party/py/t5/google/scripts/run_finetune.sh .
Treinamento determinístico
--train_gin_param = "Mesh_train_dataset_fn.seed = $ {semente}"
---train_gin_param = "utils.run.skip_seen_data = true"Modelo de idioma
--Objective = "lm" ---train_gin_param = "utils.run.model_type =" lm ""
Lançamos os seguintes pontos de verificação para modelos pré-treinados descritos em nosso artigo:
T5-Small (60 milhões de parâmetros): gs: // t5-data/pré-tereado_models/pequeno
T5-BASE (220 milhões de parâmetros): gs: // t5-data/pretred_models/base
T5-Large (770 milhões de parâmetros): gs: // t5-data/pré-tereado_models/grande
T5-3b (3 bilhões de parâmetros): gs: // t5-data/pretrening_models/3b
T5-11b (11 bilhões de parâmetros): gs: // t5-data/pretendente_models/11b
Veja aqui uma lista de pontos de verificação de modelo pré-treinado experimental adicionais.
Se você estender ou usar este trabalho, cite o artigo onde foi introduzido:
@Article {2020T5, Autor = {Colin Raffel e Noam Orheador e Adam Roberts e Katherine Lee e Sharan Narang e Michael Matena e Yanqi Zhou e Wei Li e Peter J. Liu}, Title = {Explorando os limites da aprendizagem de um unificado com um unificado Transformador de texto em texto}, Journal = {Journal of Machine Learning Research}, ano = {2020}, volume = {21}, número = {140}, páginas = {1-67}, url = {http:/ /jmlr.org/papers/v21/20-074.html}} 
