UER py
1.0.0
Inglês |中文
O pré-treinamento tornou-se uma parte essencial das tarefas de PNL. UER-py (Universal Encoder Representations) é um kit de ferramentas para pré-treinamento em corpus de domínio geral e ajuste fino em tarefas posteriores. UER-py mantém a modularidade do modelo e oferece suporte à extensibilidade da pesquisa. Ele facilita o uso de modelos de pré-treinamento existentes e fornece interfaces para os usuários ampliarem ainda mais. Com UER-py, construímos um zoológico modelo que contém modelos pré-treinados de diferentes propriedades. Consulte o Wiki do projeto UER-py para obter a documentação completa .
Abrimos o código-fonte do TencentPretrain, uma nova versão refatorada do UER-py. TencentPretrain oferece suporte a modelos multimodais e permite o treinamento de modelos grandes. Se você estiver interessado em modelos de texto de tamanho médio (com tamanhos de parâmetros inferiores a um bilhão), recomendamos continuar a usar o projeto UER-py.
UER-py possui os seguintes recursos:
Esta seção usa vários exemplos comumente usados para demonstrar como usar o UER-py. Mais detalhes são discutidos na seção Instruções. Em primeiro lugar, usamos o BERT (um modelo de pré-treinamento de texto) no conjunto de dados de classificação de sentimentos de resenhas de livros. Pré-treinamos o modelo no corpus de resenhas de livros e, em seguida, ajustamos-no no conjunto de dados de classificação de sentimentos de resenhas de livros. Existem três arquivos de entrada: corpus de resenhas de livros, conjunto de dados de classificação de sentimento de resenhas de livros e vocabulário. Todos os arquivos são codificados em UTF-8 e incluídos neste projeto.
O formato do corpus do BERT é o seguinte (uma frase por linha e os documentos são delimitados por linhas vazias):
doc1-sent1
doc1-sent2
doc1-sent3
doc2-sent1
doc3-sent1
doc3-sent2
O corpus de resenhas de livros é obtido a partir do conjunto de dados de classificação de resenhas de livros. Removemos os rótulos e dividimos uma resenha em duas partes a partir do meio para construir um documento com duas frases (ver book_review_bert.txt na pasta corpora ).
O formato do conjunto de dados de classificação é o seguinte:
label text_a
1 instance1
0 instance2
1 instance3
Rótulo e instância são separados por t . A primeira linha é uma lista de nomes de colunas. O ID do rótulo deve ser um número inteiro entre (e incluindo) 0 e n-1 para classificação de n vias.
Usamos o arquivo de vocabulário chinês do Google models/google_zh_vocab.txt , que contém 21.128 caracteres chineses.
Primeiramente, pré-processamos o corpus da resenha do livro. Na fase de pré-processamento, o corpus precisa ser processado no formato exigido pelo modelo de pré-treinamento especificado ( --data_processor ):
python3 preprocess.py --corpus_path corpora/book_review_bert.txt --vocab_path models/google_zh_vocab.txt
--dataset_path dataset.pt --processes_num 8 --data_processor bert
Observe que seis>=1.12.0 é necessário.
O pré-processamento é demorado. O uso de vários processos pode acelerar bastante a velocidade de pré-processamento ( --processes_num ). O tokenizer BERT é usado por padrão ( --tokenizer bert ). Após o pré-processamento, o texto bruto é convertido em dataset.pt , que é a entrada de pretrain.py . Em seguida, baixamos o modelo BERT chinês pré-treinado do Google google_zh_model.bin (no formato UER e o modelo original é daqui) e o colocamos na pasta de modelos . Carregamos o modelo BERT chinês pré-treinado e o pré-treinamos no corpus de resenhas de livros. O modelo de pré-treinamento geralmente é composto de camadas de incorporação, codificador e destino. Para construir um modelo de pré-treinamento, devemos fornecer informações relacionadas. O arquivo de configuração ( --config_path ) especifica os módulos e hiperparâmetros usados pelos modelos de pré-treinamento. Mais detalhes podem ser encontrados em models/bert/base_config.json . Suponha que temos uma máquina com 8 GPUs:
python3 pretrain.py --dataset_path dataset.pt --vocab_path models/google_zh_vocab.txt
--pretrained_model_path models/google_zh_model.bin
--config_path models/bert/base_config.json
--output_model_path models/book_review_model.bin
--world_size 8 --gpu_ranks 0 1 2 3 4 5 6 7
--total_steps 5000 --save_checkpoint_steps 1000 --batch_size 32
mv models/book_review_model.bin-5000 models/book_review_model.bin
Observe que o modelo treinado por pretrain.py é anexado ao sufixo que registra a etapa de treinamento ( --total_steps ). Poderíamos remover o sufixo para facilitar o uso.
Em seguida, ajustamos o modelo pré-treinado no conjunto de dados de classificação downstream. Usamos camadas de incorporação e codificador de book_review_model.bin , que é a saída de pretrain.py :
python3 finetune/run_classifier.py --pretrained_model_path models/book_review_model.bin
--vocab_path models/google_zh_vocab.txt
--config_path models/bert/base_config.json
--train_path datasets/book_review/train.tsv
--dev_path datasets/book_review/dev.tsv
--test_path datasets/book_review/test.tsv
--epochs_num 3 --batch_size 32
O caminho padrão do modelo de classificador ajustado é models/finetuned_model.bin . É perceptível que o tamanho real do lote de pré-treinamento é --batch_size times --world_size ; O tamanho real do lote da tarefa downstream (por exemplo, classificação) é --batch_size . Em seguida, fazemos inferência com o modelo ajustado.
python3 inference/run_classifier_infer.py --load_model_path models/finetuned_model.bin
--vocab_path models/google_zh_vocab.txt
--config_path models/bert/base_config.json
--test_path datasets/book_review/test_nolabel.tsv
--prediction_path datasets/book_review/prediction.tsv
--labels_num 2
--test_path especifica o caminho do arquivo a ser previsto. O arquivo deve conter a coluna text_a. --prediction_path especifica o caminho do arquivo com os resultados da previsão. Precisamos especificar explicitamente o número de rótulos por --labels_num . O conjunto de dados acima é um conjunto de dados de classificação bidirecional.
O conteúdo acima fornece maneiras básicas de usar o UER-py para pré-processar, pré-treinar, ajustar e fazer inferência. Mais casos de uso podem ser encontrados no ➡️ início rápido ⬅️ completo. O início rápido completo contém vários casos de uso, cobrindo a maioria dos cenários de aplicativos relacionados ao pré-treinamento. Recomenda-se que os usuários leiam o início rápido completo para usar o projeto de maneira razoável.
Esta seção fornece links para uma série de ➡️ dados de pré-treinamento ⬅️ . O UER pode carregar esses dados de pré-treinamento diretamente.
Esta seção fornece links para uma variedade de ➡️ conjuntos de dados downstream ⬅️ . UER pode carregar esses conjuntos de dados diretamente.
Com a ajuda do UER, pré-treinamos modelos de diferentes propriedades (por exemplo, modelos baseados em diferentes corpora, codificadores e alvos). A introdução detalhada de modelos pré-treinados e seus links para download podem ser encontrados em ➡️ modelzoo ⬅️ . Todos os modelos pré-treinados podem ser carregados diretamente pelo UER.
UER-py está organizado da seguinte forma:
UER-py/
|--uer/
| |--embeddings/ # contains modules of embedding component
| |--encoders/ # contains modules of encoder component such as RNN, CNN, Transformer
| |--decoders/ # contains modules of decoder component
| |--targets/ # contains modules of target component such as language modeling, masked language modeling
| |--layers/ # contains frequently-used NN layers
| |--models/ # contains model.py, which combines modules of different components
| |--utils/ # contains frequently-used utilities
| |--model_builder.py
| |--model_loader.py
| |--model_saver.py
| |--opts.py
| |--trainer.py
|
|--corpora/ # contains pre-training data
|--datasets/ # contains downstream tasks
|--models/ # contains pre-trained models, vocabularies, and configuration files
|--scripts/ # contains useful scripts for pre-training models
|--finetune/ # contains fine-tuning scripts for downstream tasks
|--inference/ # contains inference scripts for downstream tasks
|
|--preprocess.py
|--pretrain.py
|--README.md
|--README_ZH.md
|--requirements.txt
|--LICENSE
O código é organizado com base em componentes (por exemplo, embeddings, codificadores). Os usuários podem usá-lo e ampliá-lo com pouco esforço.
Exemplos abrangentes de uso do UER podem ser encontrados em ➡️ instruções ⬅️, que ajudam os usuários a implementar rapidamente modelos de pré-treinamento, como BERT, GPT-2, ELMo, T5 e ajustar modelos pré-treinados em uma variedade de tarefas posteriores.
O UER-py tem sido usado para vencer soluções em muitas competições de PNL. Nesta seção, fornecemos alguns exemplos de uso do UER-py para obter resultados SOTA em competições de PNL, como o CLUE. Consulte ➡️ soluções de concorrência ⬅️ para informações mais detalhadas.
@article{zhao2019uer,
title={UER: An Open-Source Toolkit for Pre-training Models},
author={Zhao, Zhe and Chen, Hui and Zhang, Jinbin and Zhao, Xin and Liu, Tao and Lu, Wei and Chen, Xi and Deng, Haotang and Ju, Qi and Du, Xiaoyong},
journal={EMNLP-IJCNLP 2019},
pages={241},
year={2019}
}
Para comunicação relacionada a este projeto, entre em contato com Zhe Zhao ([email protected]; [email protected]) ou Yudong Li ([email protected]) ou Cheng Hou ([email protected]) ou Wenhang Shi ([email protected]).
Este trabalho é instruído pelos meus mentores empresariais Qi Ju , Xuefeng Yang , Haotang Deng e pelos mentores escolares Tao Liu , Xiaoyong Du .
Também recebemos muita ajuda de Weijie Liu, Lusheng Zhang, Jianwei Cui, Xiayu Li, Weiquan Mao, Xin Zhao, Hui Chen, Jinbin Zhang, Zhiruo Wang, Peng Zhou, Haixiao Liu e Weijian Wu.
