Bert Multi Label Text Classification

Classificação de texto com vários rótulos de Bert por Pytorch

Este repo contém uma implementação Pytorch do modelo BERT e XLNET pré-treinado para classificação de texto com vários rótulos.

Estrutura do código

Na raiz do projeto, você verá:

 ├── pybert
|  └── callback
|  |  └── lrscheduler.py　　
|  |  └── trainingmonitor.py　
|  |  └── ...
|  └── config
|  |  └── basic_config.py #a configuration file for storing model parameters
|  └── dataset　　　
|  └── io　　　　
|  |  └── dataset.py　　
|  |  └── data_transformer.py　　
|  └── model
|  |  └── nn　
|  |  └── pretrain　
|  └── output #save the ouput of model
|  └── preprocessing #text preprocessing 
|  └── train #used for training a model
|  |  └── trainer.py 
|  |  └── ...
|  └── common # a set of utility functions
├── run_bert.py
├── run_xlnet.py

Dependências

• CSV
• TQDM
• Numpy
• salmoura
• Scikit-Learn
• Pytorch 1.1+
• matplotlib
• Pandas
• Transformers = 2.5.1

Como usar o código

Você precisa baixar o modelo BERT pré -traido e o modelo XLNET.

Bert: Bert-Base-Basered

XLNET: XLNET-BASE-CASE

1. Baixe o modelo Bert pré -traido do S3

2. Baixe o arquivo de configuração do Bert de S3

3. Baixe o arquivo de vocabulário Bert de S3

4. Renomear:

   • bert-base-uncased-pytorch_model.bin para pytorch_model.bin
   • bert-base-uncased-config.json PARA config.json
   • bert-base-uncased-vocab.txt para bert_vocab.txt

5. Coloque o arquivo de model , config e vocab no diretório /pybert/pretrain/bert/base-uncased .

6. pip install pytorch-transformers do github.

7. Faça o download dos dados Kaggle e coloque no pybert/dataset .

   • Você pode modificar o io.task_data.py para adaptar seus dados.

8. Modifique as informações de configuração em pybert/configs/basic_config.py (o caminho dos dados, ...).

9. Execute python run_bert.py --do_data para pré -processamento de dados.

10. Execute python run_bert.py --do_train --save_best --do_lower_case para ajustar o modelo Bert.

11. Run run_bert.py --do_test --do_lower_case para prever novos dados.

treinamento

 [training] 8511/8511 [>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] -0.8s/step- loss: 0.0640
training result:
[2019-01-14 04:01:05]: bert-multi-label trainer.py[line:176] INFO  
Epoch: 2 - loss: 0.0338 - val_loss: 0.0373 - val_auc: 0.9922

Figura de treinamento

resultado

 - - - - train report every label - - - - -
Label : toxic - auc : 0.9903
Label : severe_toxic - auc : 0.9913
Label : obscene - auc : 0.9951
Label : threat - auc : 0.9898
Label : insult - auc : 0.9911
Label : identity_hate - auc : 0.9910
- - - - valid report every label - - - - -
Label : toxic - auc : 0.9892
Label : severe_toxic - auc : 0.9911
Label : obscene - auc : 0.9945
Label : threat - auc : 0.9955
Label : insult - auc : 0.9903
Label : identity_hate - auc : 0.9927 

Pontas

• Ao converter o ponto de verificação do tensorflow no pytorch, espera -se que escolha o "bert_model.ckpt", em vez de "bert_model.ckpt.index", como o arquivo de entrada. Caso contrário, você verá que o modelo não pode aprender nada e fornecer quase as mesmas saídas aleatórias para quaisquer entradas. Isso significa que, de fato, você não carregou o verdadeiro ckpt para o seu modelo
• Ao usar várias GPUs, os cálculos não-tensores, como precisão e F1_SCore, não são suportados por instância do Dataparallel
• Conforme recomendado por JocOB em seu artigo https://arxiv.org/pdf/1810.04805.pdf, em tarefas de ajuste fino, os hiperparâmetros devem definir como seguinte: Batch_size : 16 ou 32, aprendizagem : 5e-5 ou 2e-5 ou 35, num .
• O modelo pré -treinado tem um limite para a sentença de entrada de que seu comprimento não deve ser maior que 512, a posição máxima que incorporava diminua. Os dados fluem para o modelo como: RAW_DATA -> Modelo de palavras ->. Observe que o comprimento das peças de palavras é geralmente maior que o de Raw_data; portanto, um comprimento máximo seguro de RAW_Data está em ~ 128 - 256
• Após o teste, descobrimos que todas as camadas poderiam obter resultados muito melhores do que aqueles de apenas ajuste a última camada de classe. O último é na verdade uma maneira baseada em recursos