naacl_transfer_learning_tutorial

Repositório de código NAACL 2019 Tutorial sobre "Learning de transferência no processamento de linguagem natural"

O tutorial foi concedido em 2 de junho na NAACL 2019 em Minneapolis, MN, EUA por Sebastian Ruder, Matthew Peters, Swabha Swayamdipta e Thomas Wolf.

Aqui está a página da web dos tutoriais da NAACL para obter mais informações.

Os slides para o tutorial podem ser encontrados aqui: https://tinyurl.com/naacltransfer.

Um notebook do Google Colab com todo o código do tutorial pode ser encontrado aqui: https://tinyurl.com/naacltransfercolab.

O atual repositório também pode ser acessado com o seguinte URL curto: https://tinyurl.com/naacltransfercode

Resumo

O paradigma clássico de aprendizado de máquina supervisionado é baseado no aprendizado de isolamento, um único modelo preditivo para uma tarefa usando um único conjunto de dados. Essa abordagem requer um grande número de exemplos de treinamento e tem um desempenho melhor para tarefas bem definidas e estreitas. A aprendizagem de transferência refere -se a um conjunto de métodos que estendem essa abordagem, aproveitando os dados de domínios ou tarefas adicionais para treinar um modelo com melhores propriedades de generalização.

Nos últimos dois anos, o campo do processamento de linguagem natural (PNL) testemunhou o surgimento de vários métodos e arquiteturas de aprendizado de transferência, o que melhorou significativamente com o estado da arte em uma ampla gama de tarefas de PNL.

Essas melhorias, juntamente com a ampla disponibilidade e a facilidade de integração desses métodos, lembram os fatores que levaram ao sucesso de incorporações de palavras pré -rastreadas e imagenete com a visão computacional, e indicam que esses métodos provavelmente se tornarão uma ferramenta comum na paisagem do NLP, bem como uma importante direção de pesquisa.

Apresentaremos uma visão geral dos métodos modernos de aprendizado de transferência na PNL, como os modelos são pré-treinados, quais informações as representações que aprendem capturam e revisam exemplos e estudos de caso sobre como esses modelos podem ser integrados e adaptados em tarefas de PNL a jusante.

Visão geral

Essa base de código tenta se apresentar da maneira mais simples e compacta, algumas das principais técnicas de aprendizado de transferência, que surgiram nos últimos anos. O código deste repositório não tenta ser de ponta. No entanto, foi feito um esforço para alcançar um desempenho razoável e com algumas modificações para serem competitivas com o estado atual da arte.

Especial esforço foi feito para

• Verifique se o código atual pode ser usado o mais facilmente possível, em particular, hospedando modelos e conjuntos de dados pré -treinados;
• Mantenha a base de código atual o mais compacta e independente possível para facilitar a manipulação e o entendimento.

Atualmente, a base de código compreende:

• pretraining_model.py : um modelo de transformador com uma arquitetura do tipo GPT-2 como o modelo básico pré-treinado;
• pretraining_train.py : um script pré-treinado para treinar esse modelo com um objetivo de modelagem de idiomas em uma seleção de grandes conjuntos de dados (Wikitext-103, SimpleBooks-92) usando treinamento distribuído, se disponível;
• finetuning_model.py : várias arquiteturas baseadas no modelo do transformador para ajuste fino (com uma cabeça de classificação na parte superior, com adaptadores);
• finetuning_train.py : um script de ajuste fino para ajustar essas arquiteturas em uma tarefa de classificação (IMDB).

Instalação

Para usar esta base de código, basta clonar o repositório do GitHub e instalar os requisitos como este:

git clone https://github.com/huggingface/naacl_transfer_learning_tutorial
cd naacl_transfer_learning_tutorial
pip install -r requirements.txt

Pré-treinamento

Para pré-treinar o transformador, execute o script pretraining_train.py como este:

python ./pretraining_train.py

ou usando treinamento distribuído como este (para um servidor de 8 GPU):

python -m torch.distributed.launch --nproc_per_node 8 ./pretraining_train.py

O script de pré-treinamento será:

• Baixe wikitext-103 para pré-treinamento (padrão),
• instanciar um modelo de transformador de parâmetros de 50m e treiná -lo para 50 épocas,
• registre as experiências em Tensorboard e em uma pasta em ./runs ,
• Salvar pontos de verificação na pasta de log.

A pré-treinamento de uma perplexidade de validação de ~ 29 no Wikitext-103 levará cerca de 15h em 8 GPUs V100 (podem ser interrompidos anteriormente). Se você estiver interessado no SOTA, existem algumas razões pelas quais a perplexidade da validação é um pouco maior que a perplexidade equivalente ao transformador-xl (cerca de 24). O principal motivo é o uso de um vocabulário aberto (sub-palavras para Bert Tokenizer) em vez de um vocabulário fechado (veja esta postagem do blog de Sebastian Mielke para obter alguma explicação)

Várias opções de pré-treinamento estão disponíveis, você pode listá-las com:

python ./pretraining_train.py --help

Afinação

Para ajustar o transformador pré-treinado, execute o script finetuning_train.py como este:

python ./finetuning_train.py --model_checkpoint PATH-TO-YOUR-PRETRAINED-MODEL-FOLDER

PATH-TO-YOUR-PRETRAINED-MODEL-FOLDER pode ser, por exemplo ./runs/May17_17-47-12_my_big_server

ou usando treinamento distribuído como este (para um servidor de 8 GPU):

python -m torch.distributed.launch --nproc_per_node 8 ./finetuning_train.py  --model_checkpoint PATH-TO-YOUR-PRETRAINED-MODEL-FOLDER

Várias opções de ajuste fino estão disponíveis, você pode listá-las com:

python ./finetuning_train.py --help