fancy nlp
1.0.0
PNL para humano. Um kit de ferramentas de processamento de linguagem natural (NLP) rápido e fácil de usar, satisfazendo sua imaginação sobre a PNL.
→ Versão em inglês
Introdução Básica • Instalação • Guia de Iniciação • Tutorial detalhado • Honras • Como contribuir com código • Citações • Agradecimentos
Fancy-NLP é uma ferramenta de mineração de conhecimento de texto para criar retratos de produtos construídos pela equipe de estratégia de publicidade de produtos da Tencent. Ele suporta uma variedade de tarefas comuns de PNL, como extração de entidades, classificação de texto e correspondência de similaridade de texto. Comparado com as estruturas atuais comumente usadas no setor, ele pode apoiar os usuários a implementar uma implementação funcional rápida: ele pode não apenas atender à profunda personalização dos modelos por usuários avançados, mas também permitir que usuários comuns usem rapidamente modelos pré-treinados para praticar rapidamente a prática funcional. No cenário atual de negócios de publicidade de produtos, usamos essa ferramenta para explorar rapidamente as características de dados maciços do produto, apoiando assim módulos como recomendações de produtos de publicidade.
A intenção original do projeto é fornecer um conjunto de ferramentas de NLP fáceis de usar, que são direcionadas diretamente aos cenários de uso e atendem às necessidades dos usuários para tarefas de PNL, para que os usuários não precisem lidar com o pré-processamento complexo e outros processos intermediários, e completarem diretamente várias tarefas de NLP para o texto da linguagem natural de entrada, percebendo o que pensam que eles pensam que são o que eles pensam!
O que é chique? Para muitas tarefas atuais de PNL, como reconhecimento de entidade nomeado (NER), classificação de texto e correspondência de similaridade de texto (correspondência de pares de frases (SPM), a maioria das ferramentas é projetada para favorecer o treinamento e a avaliação do modelo. Processamento de cada link da tarefa PNL no Fancy-NLP e aplique com eficiência o modelo a cenários de demanda reais.
Atualmente, o Fancy-NLP é suportado para uso em ambientes Python 3 e foi totalmente testado no Python 3.6. O TensorFlow 2.x é totalmente dependente da versão atual. Se você tiver alguma preocupação com a compatibilidade do módulo, recomendamos que você use o VirtualENV para criar um ambiente virtual para usar essa ferramenta.
Fancy-NLP suporta instalação de um clique usando pip :
pip install fancy-nlpNo guia de início, usaremos modelos pré-treinados para levá-lo a entender e experimentar rapidamente as funções básicas do Fancy-NLP.
Nota: Continuaremos otimizando o modelo de reconhecimento de entidades de vários cenários (diferentes dados anotados) para os usuários usarem diretamente. Se você tiver conjuntos de dados relevantes, também poderá nos dar um feedback positivo no problema.
A versão atual do Fancy-NLP pode carregar o modelo NER treinado usando dados do subconjunto MSRA NER por padrão. Ele pode identificar estruturas organizacionais (ORG), locais (LOCs) e pessoas (por) entidades no texto chinês. O modelo básico carregado por padrão é que os usuários experimentem diretamente. Se você deseja usar seu próprio modelo personalizado diretamente, consulte a introdução no tutorial detalhado subsequente para criar seu sistema de extração de entidades.
> >> from fancy_nlp . applications import NER
> >> ner_app = NER ()Quando você executa o código acima pela primeira vez, o modelo NER pré-treinado será baixado da nuvem.
> >> ner_app . analyze ( '同济大学位于上海市杨浦区，校长为陈杰' )
{ 'text' : '同济大学位于上海市杨浦区，校长为陈杰' ,
'entities' : [
{ 'name' : '同济大学' ,
'type' : 'ORG' ,
'score' : 1.0 ,
'beginOffset' : 0 ,
'endOffset' : 4 },
{ 'name' : '上海市' ,
'type' : 'LOC' ,
'score' : 1.0 ,
'beginOffset' : 6 ,
'endOffset' : 9 },
{ 'name' : '杨浦区' ,
'type' : 'LOC' ,
'score' : 1.0 ,
'beginOffset' : 9 ,
'endOffset' : 12 },
{ 'name' : '陈杰' ,
'type' : 'PER' ,
'score' : 1.0 ,
'beginOffset' : 16 ,
'endOffset' : 18 }]} > >> ner_app . restrict_analyze ( '同济大学位于上海市杨浦区，校长为陈杰' )
{ 'text' : '同济大学位于上海市杨浦区，校长为陈杰' ,
'entities' : [
{ 'name' : '同济大学' ,
'type' : 'ORG' ,
'score' : 1.0 ,
'beginOffset' : 0 ,
'endOffset' : 4 },
{ 'name' : '杨浦区' ,
'type' : 'LOC' ,
'score' : 1.0 ,
'beginOffset' : 9 ,
'endOffset' : 12 },
{ 'name' : '陈杰' ,
'type' : 'PER' ,
'score' : 1.0 ,
'beginOffset' : 16 ,
'endOffset' : 18 }]} >>> ner_app.predict('同济大学位于上海市杨浦区，校长为陈杰')
['B-ORG',
'I-ORG',
'I-ORG',
'I-ORG',
'O',
'O',
'B-LOC',
'I-LOC',
'I-LOC',
'B-LOC',
'I-LOC',
'I-LOC',
'O',
'O',
'O',
'O',
'B-PER',
'I-PER']
A Fancy-NLP é carregada por padrão com o modelo de classificação de texto treinado no conjunto de dados de classificação de título de notícias chinesas atualmente publicado, que pode prever a categoria de notícias à qual pertence ao texto do título de notícias.
> >> from fancy_nlp . applications import TextClassification
> >> text_classification_app = TextClassification ()Quando você executa o programa acima pela primeira vez, o modelo pré-treinado será baixado da nuvem.
> >> text_classification_app . predict ( '苹果iOS占移动互联网流量份额逾65% 位居第一' )
'科技' > >> text_classification_app . analyze ( '苹果iOS占移动互联网流量份额逾65% 位居第一' )
( '科技' , 0.9996544 )O Fancy-NLP é carregado por padrão no modelo de correspondência de similaridade de texto treinado no conjunto de dados de correspondência de perguntas sobre o atendimento ao cliente da Webank atualmente publicado, que pode prever se expressa a mesma intenção para os pares de texto fornecidos.
> >> from fancy_nlp . applications import SPM
> >> spm_app = SPM ()Quando você executa o programa acima pela primeira vez, o modelo de correspondência de similaridade de texto pré-treinado será baixado da nuvem.
> >> spm_app . predict (( '未满足微众银行审批是什么意思' , '为什么我未满足微众银行审批' ))
'1' No resultado da previsão, 1 representa a mesma intenção ou texto semelhante 0 representa a intenção diferente ou texto diferente.
> >> spm_app . analyze (( '未满足微众银行审批是什么意思' , '为什么我未满足微众银行审批' ))
( '1' , array ([ 1.6599501e-09 , 1.0000000e+00 ], dtype = float32 ))No tutorial detalhado , você pode aprender a usar o Fancy-NLP para criar modelos personalizados que atendam a cenários personalizados usando seus próprios conjuntos de dados e têm uma compreensão mais abrangente da interface da Fancy-NLP.
Para experimentar completamente o seguinte tutorial, você precisa baixar o modelo de dados e o modelo BERT que usamos:
86geqk7e6rb7 Você pode mover os dados baixados para o mesmo nível do diretório examples , e a estrutura final do diretório é a seguinte:
.
├── datasets
│ ├── ner
│ │ └── msra
│ │ ├── test_data
│ │ └── train_data
│ ├── spm
│ │ └── webank
│ │ ├── BQ_dev.txt
│ │ ├── BQ_test.txt
│ │ └── BQ_train.txt
│ └── text_classification
│ └── toutiao
│ ├── toutiao_cat_data.txt
│ └── toutiao_label_dict.txt
├── examples
│ ├── bert_combination.py
│ ├── bert_fine_tuning.py
│ ├── bert_single.py
│ ├── ner_example.py
│ ├── spm_example.py
│ └── text_classification_example.py
└── pretrained_embeddings
└── chinese_L-12_H-768_A-12
├── bert_config.json
├── bert_model.ckpt.data-00000-of-00001
├── bert_model.ckpt.index
├── bert_model.ckpt.meta
└── vocab.txt
Para que você possa executar o programa de amostra diretamente. Por exemplo, python examples/ner_example.py .
Ainda usamos os dados do subconjunto do MSRA NER mencionados acima como um exemplo para introduzir como usar os conjuntos de dados existentes para treinar nosso próprio modelo de reconhecimento de entidades. Para uma versão completa de todos os seguintes trechos de código, consulte examples/ner_example.py .
No Fancy-NLP, os aplicativos de reconhecimento de entidades suportam o uso de formatos de conjunto de dados NER padrão, cada caractere a ser identificado e sua tag correspondente é separada por t , e as frases são separadas por linhas em branco. O formato da tag pode ser um formato padrão comum, como BIO e BIOES .
Usando a interface fornecida pelo Fancy-NLP, podemos carregar diretamente o conjunto de dados e processá-lo no formato exigido pelo modelo.
from fancy_nlp . applications import NER
ner_app = NER ( use_pretrained = False )
from fancy_nlp . utils import load_ner_data_and_labels
train_data , train_labels = load_ner_data_and_labels ( 'datasets/ner/msra/train_data' )
valid_data , valid_labels = load_ner_data_and_labels ( 'datasets/ner/msra/test_data' ) load_ner_data_and_labels implementa o carregamento eficaz dos conjuntos de dados NER. Você pode usar diretamente o caminho do arquivo dos dados (conjunto de treinamento, conjunto de validação ou conjunto de testes) para ser carregado como parâmetros. O conjunto de testes é usado como o conjunto de validação. Nas tarefas reais, você deve ter seus próprios conjuntos de validação e testes independentes para obter resultados valiosos de avaliação de testes.
Após obter dados válidos, o aplicativo NER pode começar a treinar diretamente o modelo.
checkpoint_dir = 'pretrained_models'
model_name = 'msra_ner_bilstm_cnn_crf'
ner_app . fit ( train_data , train_labels , valid_data , valid_labels ,
ner_model_type = 'bilstm_cnn' ,
char_embed_trainable = True ,
callback_list = [ 'modelcheckpoint' , 'earlystopping' , 'swa' ],
checkpoint_dir = checkpoint_dir ,
model_name = model_name ,
load_swa_model = True ) Para a interface fit do aplicativo NER, você precisa passar no conjunto de treinamento e no conjunto de amostras do conjunto de validação que foram processadas antes. Os significados dos parâmetros restantes são os seguintes:
ner_model_type : Indica o nome do modelo a ser usado. Neste exemplo, o modelo bilstm_cnn é usado;char_embed_trainable : se a camada de vetor da palavra pode ser um ajuste fino. Neste exemplo, ele está definido como True , indicando que o ajuste fino pode ser realizado;callback_list : o nome da função de retorno de chamada que precisa ser usada. As funções de retorno de chamada usadas neste exemplo são:modelcheckpoint : use a função de ponto de verificação do modelo. Após cada iteração, salve o modelo treinado;earlystopping : use a função de parada antecipada. Se o desempenho do modelo não melhorar após N rodadas (padrão n = 5), o treinamento será encerrado;swa : SWA significa média de peso estocástico, que é uma estratégia de integração de modelos comum que pode efetivamente melhorar o desempenho do modelo. Para mais detalhes, consulte a introdução no artigo original;checkpoint_dir : o caminho do diretório para salvar o arquivo de modelo;model_name : o nome do arquivo do arquivo de modelo;load_swa_model : se deve carregar o peso do modelo SWA após o treino do modelo. Definido como True aqui, indicando o uso do modelo SWA; test_data , test_labels = load_ner_data_and_labels ( 'datasets/ner/msra/test_data' )
ner_app . score ( test_data , test_labels ) Aqui, load_ner_data_and_labels ainda é usado para processar dados do conjunto de testes. Depois de obter um formato de dados válido, use a interface score do aplicativo NER para obter a pontuação do modelo no conjunto de testes.
Após treinar o modelo, todos os arquivos relacionados ao modelo exigidos pela tarefa precisam ser salvos para facilitar o uso de modelos treinados por NLP sofisticados em outros aplicativos externos.
import os
ner_app . save (
preprocessor_file = os . path . join ( checkpoint_dir , f' { model_name } _preprocessor.pkl' ),
json_file = os . path . join ( checkpoint_dir , f' { model_name } .json' )) A interface save do aplicativo NER pode ser usada para persistir o arquivo de estrutura do modelo (JSON), o arquivo de peso (HDF5) e os resultados relacionados ao pré -processamento (pickle):
modelcheckpoint ; ner_app . load (
preprocessor_file = os . path . join ( checkpoint_dir , f' { model_name } _preprocessor.pkl' ),
json_file = os . path . join ( checkpoint_dir , f' { model_name } .json' ),
weights_file = os . path . join ( checkpoint_dir , f' { model_name } _swa.hdf5' )) No momento, ner_app já tem a capacidade de prever amostras e você pode concluir as funções de previsão relevantes mencionadas no guia introdutório . Por exemplo, analyze , restrict_analyze .
Ainda usamos o conjunto de dados de classificação de títulos de notícias chinês mencionado acima como um exemplo para introduzir como usar o conjunto de dados existente para treinar nosso próprio modelo de classificação de texto. Para uma versão completa de todos os seguintes trechos de código, consulte examples/text_classification_example.py .
No Fancy-NLP, os aplicativos de classificação de texto suportam formatos de conjunto de dados separados por delimitadores fixos usando o texto original. Eles podem ter colunas redundantes independentes das tarefas de classificação de texto. Eles só precisam garantir que a coluna da etiqueta e a coluna de texto de entrada estejam em uma posição fixa unificada.
Além disso, para tags de classificação, também é necessário um arquivo de mapeamento de tags e IDs de tags, que consiste em duas colunas: a primeira coluna é o nome original da tag no conjunto de dados, geralmente alguns IDs codificados; A segunda coluna é o nome legível correspondente ao nome original da tag. A correspondência deste arquivo será usada para produzir nomes de etiquetas legíveis diretamente quando o modelo for previsto.
Usando a interface fornecida pelo Fancy-NLP, podemos carregar diretamente o conjunto de dados e processá-lo no formato exigido pelo modelo.
from fancy_nlp . applications import TextClassification
text_classification_app = TextClassification ( use_pretrained = False )
data_file = 'datasets/text_classification/toutiao/toutiao_cat_data.txt'
from fancy_nlp . utils import load_text_classification_data_and_labels
train_data , train_labels , valid_data , valid_labels , test_data , test_labels =
load_text_classification_data_and_labels ( data_file ,
label_index = 1 ,
text_index = 3 ,
delimiter = '_!_' ,
split_mode = 2 ,
split_size = 0.3 ) load_ner_data_and_labels implementa o carregamento eficaz dos conjuntos de dados de classificação de texto. Você pode usar diretamente o caminho do arquivo dos dados (conjunto de treinamento, conjunto de validação ou conjunto de testes) para ser carregado como parâmetros. Os dados completos são usados aqui para dividir o conjunto de treinamento, o conjunto de validação e o conjunto de testes. Além do arquivo de dados, o significado específico dos parâmetros restantes acima é:
label_index : a posição da tag de classificação no arquivo de dados (o número da posição é iniciado em 0);text_index : a localização do texto a ser classificada no arquivo de dados;delimiter : o separador entre as colunas do arquivo de dados;split_mode : indica como dividir os dados originais alterando os parâmetros. em:split_size : Razão da divisão de dados. Quando split_mode=1 , significa que os dados que dividem split_size dos dados originais serão usados como conjunto de verificação; Quando split_mode=2 , significa que os dados que dividem split_size dos dados originais serão usados como a soma do conjunto de verificação e do conjunto de testes e as proporções do conjunto de verificação e o conjunto de testes de cada conta da metade. Após obter dados válidos, o aplicativo de classificação de texto pode começar a treinar o modelo diretamente.
dict_file = 'datasets/text_classification/toutiao/toutiao_label_dict.txt'
model_name = 'toutiao_text_classification_cnn'
checkpoint_dir = 'pretrained_models'
text_classification_app . fit (
train_data , train_labels , valid_data , valid_labels ,
text_classification_model_type = 'cnn' ,
char_embed_trainable = True ,
callback_list = [ 'modelcheckpoint' , 'earlystopping' , 'swa' ],
checkpoint_dir = checkpoint_dir ,
model_name = model_name ,
label_dict_file = dict_file ,
max_len = 60 ,
load_swa_model = True ) Para a interface fit de um aplicativo de classificação de texto, você precisa passar no conjunto de treinamento e no conjunto de amostras do conjunto de validação que foram processadas antes. Os significados dos parâmetros restantes são os seguintes:
text_classification_model_type : indica o nome do modelo a ser usado. Neste exemplo, o modelo cnn é usado;char_embed_trainable : se a camada de vetor da palavra pode ser um ajuste fino. Neste exemplo, ele está definido como True , indicando que o ajuste fino pode ser realizado;callback_list : o nome da função de retorno de chamada que precisa ser usada. As funções de retorno de chamada usadas neste exemplo são:modelcheckpoint : use a função de ponto de verificação do modelo. Após cada iteração, salve o modelo treinado;earlystopping : use a função de parada antecipada. Se o desempenho do modelo não melhorar após N rodadas (padrão n = 5), o treinamento será encerrado;swa : SWA significa média de peso estocástico, que é uma estratégia de integração de modelos comum que pode efetivamente melhorar o desempenho do modelo. Para mais detalhes, consulte a introdução no artigo original;checkpoint_dir : o caminho do diretório para salvar o arquivo de modelo;model_name : o nome do arquivo do arquivo de modelo;label_dict_file : Um arquivo de dicionário de etiqueta, que consiste em duas colunas: a primeira coluna é o nome original do rótulo no conjunto de dados, geralmente alguns IDs codificados; A segunda coluna é o nome legível correspondente ao nome original do rótulo;max_len : para o comprimento máximo retido pelo texto de entrada, o texto além desse comprimento será truncado;load_swa_model : se deve carregar o peso do modelo SWA após o treino do modelo. Definido como True aqui, indicando o uso do modelo SWA; text_classification_app . score ( test_data , test_labels ) Aqui você pode usar diretamente a interface score do aplicativo de classificação de texto para obter a pontuação do modelo no conjunto de testes.
Após treinar o modelo, todos os arquivos relacionados ao modelo exigidos pela tarefa precisam ser salvos para facilitar o uso de modelos treinados por NLP sofisticados em outros aplicativos externos.
import os
text_classification_app . save (
preprocessor_file = os . path . join ( checkpoint_dir , f' { model_name } _preprocessor.pkl' ),
json_file = os . path . join ( checkpoint_dir , f' { model_name } .json' )) A interface save dos aplicativos de classificação de texto pode ser usada para persistir o arquivo de estrutura do modelo (JSON), o arquivo de peso (HDF5) e os resultados relacionados ao pré -processamento (pickle):
modelcheckpoint . text_classification_app . load (
preprocessor_file = os . path . join ( checkpoint_dir , f' { model_name } _preprocessor.pkl' ),
json_file = os . path . join ( checkpoint_dir , f' { model_name } .json' ),
weights_file = os . path . join ( checkpoint_dir , f' { model_name } _swa.hdf5' )) No momento, text_classification_app já tem a capacidade de prever amostras e você pode concluir as funções de previsão relevantes mencionadas no guia introdutório . Por exemplo, predict , analyze .
Ainda usamos o conjunto de dados de correspondência de perguntas sobre o atendimento ao cliente da Webank mencionado acima como um exemplo para introduzir como usar o conjunto de dados existente para treinar nosso próprio modelo de correspondência de similaridade de texto. Para uma versão completa de todos os seguintes trechos de código, consulte examples/spm_example.py .
No Fancy-NLP, o aplicativo de tarefa de correspondência de similaridade de texto suporta o uso do texto original em um formato de conjunto de dados separado por t , que consiste em três colunas: a primeira coluna e a segunda coluna são um conjunto de pares de texto, respectivamente; A terceira coluna é uma etiqueta de amostra, 1 significa que a semântica de texto é semelhante e 0 significa diferente.
Usando a interface fornecida pelo Fancy-NLP, podemos carregar diretamente o conjunto de dados e processá-lo no formato exigido pelo modelo.
from fancy_nlp . applications import SPM
spm_app = applications . SPM ( use_pretrained = False )
train_file = 'datasets/spm/webank/BQ_train.txt'
valid_file = 'datasets/spm/webank/BQ_dev.txt'
from fancy_nlp . utils import load_spm_data_and_labels
train_data , train_labels = load_spm_data_and_labels ( train_file )
valid_data , valid_labels = load_spm_data_and_labels ( valid_file ) load_spm_data_and_labels implementa o carregamento eficaz dos conjuntos de dados correspondentes à similaridade de texto. Você pode usar diretamente o caminho do arquivo dos dados (conjunto de treinamento, conjunto de validação ou conjunto de testes) para ser carregado como parâmetros.
Após obter dados válidos, o aplicativo de correspondência de similaridade de texto pode começar a treinar o modelo diretamente.
model_name = 'spm_siamese_cnn'
checkpoint_dir = 'pretrained_models'
spm_app . fit ( train_data , train_labels , valid_data , valid_labels ,
spm_model_type = 'siamese_cnn' ,
word_embed_trainable = True ,
callback_list = [ 'modelcheckpoint' , 'earlystopping' , 'swa' ],
checkpoint_dir = checkpoint_dir ,
model_name = model_name ,
max_len = 60 ,
load_swa_model = True ) Para a interface fit do aplicativo de correspondência de similaridade de texto, você precisa passar nas amostras de conjunto de treinamento e validação que foram processadas antes. O significado dos parâmetros restantes é o seguinte:
spm_model_type : indica o nome do modelo a ser usado. Neste exemplo, o modelo siamese_cnn é usado;word_embed_trainable : se a camada de vetor da palavra pode ser um ajuste fino. Neste exemplo, ele está definido como True , indicando que o ajuste fino pode ser realizado;callback_list : o nome da função de retorno de chamada que precisa ser usada. As funções de retorno de chamada usadas neste exemplo são:modelcheckpoint : use a função de ponto de verificação do modelo. Após cada iteração, salve o modelo treinado;earlystopping : use a função de parada antecipada. Se o desempenho do modelo não melhorar após N rodadas (padrão n = 5), o treinamento será encerrado;swa : SWA significa média de peso estocástico, que é uma estratégia de integração de modelos comum que pode efetivamente melhorar o desempenho do modelo. Para mais detalhes, consulte a introdução no artigo original;checkpoint_dir : o caminho do diretório para salvar o arquivo de modelo;model_name : o nome do arquivo do arquivo de modelo;max_len : para o comprimento máximo retido pelo texto de entrada, o texto além desse comprimento será truncado;load_swa_model : se deve carregar o peso do modelo SWA após o treino do modelo. Definido como True aqui, indicando o uso do modelo SWA; test_file = 'datasets/spm/webank/BQ_test.txt'
test_data , test_labels = load_spm_data_and_labels ( test_file )
spm_app . score ( test_data , test_labels ) Aqui você pode usar diretamente a interface score do aplicativo correspondente à similaridade do texto para obter a pontuação do modelo no conjunto de testes.
Após treinar o modelo, todos os arquivos relacionados ao modelo exigidos pela tarefa precisam ser salvos para facilitar o uso de modelos treinados por NLP sofisticados em outros aplicativos externos.
import os
spm_app . save (
preprocessor_file = os . path . join ( checkpoint_dir , f' { model_name } _preprocessor.pkl' ),
json_file = os . path . join ( checkpoint_dir , f' { model_name } .json' )) A interface save do aplicativo de correspondência de similaridade de texto pode ser usada para persistir o arquivo de estrutura do modelo (JSON), o arquivo de peso (HDF5) e os resultados relacionados ao pré -processamento (Pickle):
modelcheckpoint . spm_app . load (
preprocessor_file = os . path . join ( checkpoint_dir , f' { model_name } _preprocessor.pkl' ),
json_file = os . path . join ( checkpoint_dir , f' { model_name } .json' ),
weights_file = os . path . join ( checkpoint_dir , f' { model_name } _swa.hdf5' )) No momento, spm_app já tem a capacidade de prever amostras e você pode continuar a concluir as funções de previsão relevantes mencionadas no Guia Introdutório . Por exemplo, predict , analyze .
O FACNY-NLP fornece vários métodos para usar o modelo Bert :
Para usar o BERT no Fancy-NLP, você só precisa baixar o modelo BERT pré-treinado (como o modelo BERT chinês fornecido pelo Google, o modelo Ernie fornecido pelo Baidu (Código de Extração: IQ74) e o modelo BERT-WWM fornecido pelo Harbin Institute of Technology). Depois disso, você pode passar no caminho do arquivo de vocabulário do modelo BERT, arquivo de configuração e arquivo de modelos no método fit do aplicativo relevante. A seguir, é apresentado um exemplo do aplicativo de reconhecimento de entidade. Para o código de exemplo completo, consulte examples/bert_fine_tuning.py , examples/bert_single.py e examples/bert_combination.py .
Observe que o modelo BERT só pode ser usado com vetores de caracteres, não com vetores de palavras.
import tensorflow as tf
from fancy_nlp . applications import NER
ner_app = NER ( use_pretrained = False )
from fancy_nlp . utils import load_ner_data_and_labels
train_data , train_labels = load_ner_data_and_labels ( 'datasets/ner/msra/train_data' )
valid_data , valid_labels = load_ner_data_and_labels ( 'datasets/ner/msra/test_data' )
ner_app . fit ( train_data , train_labels , valid_data , valid_labels ,
ner_model_type = 'bert' ,
use_char = False ,
use_word = False ,
use_bert = True ,
bert_vocab_file = 'pretrained_embeddings/chinese_L-12_H-768_A-12/vocab.txt' ,
bert_config_file = 'pretrained_embeddings/chinese_L-12_H-768_A-12/bert_config.json' ,
bert_checkpoint_file = 'pretrained_embeddings/chinese_L-12_H-768_A-12/bert_model.ckpt' ,
bert_trainable = True ,
optimizer = tf . keras . optimizers . Adam ( 1e-5 ),
callback_list = [ 'modelcheckpoint' , 'earlystopping' , 'swa' ],
checkpoint_dir = 'pretrained_models' ,
model_name = 'msra_ner_bert_crf' ,
load_swa_model = True )No trecho de código acima, é importante observar:
ner_model_type : Defina o tipo de modelo como bert ;use_char : defina para não usar vetores no nível do caractere;use_word : defina para não usar vetores de nível de palavra como entrada auxiliar;use_bert : Ao ajustar o modelo Bert, defina apenas para usar apenas a entrada do Bert;bert_vocab_file , bert_config_file , bert_checkpoint_file : o caminho para os arquivos relacionados ao modelo BERTbert_trainable : Defina os parâmetros do modelo BERT como estado treinável, ou seja, ajuste fino;optimizer : defina o otimizador para o modelo BERT. Ao ajustar o modelo Bert, a taxa de aprendizado do otimizador precisa ser ajustada para um nível menor. from fancy_nlp . applications import NER
ner_app = NER ( use_pretrained = False )
from fancy_nlp . utils import load_ner_data_and_labels
train_data , train_labels = load_ner_data_and_labels ( 'datasets/ner/msra/train_data' )
valid_data , valid_labels = load_ner_data_and_labels ( 'datasets/ner/msra/test_data' )
ner_app . fit ( train_data , train_labels , valid_data , valid_labels ,
ner_model_type = 'bilstm_cnn' ,
use_char = False ,
use_word = False ,
use_bert = True ,
bert_vocab_file = 'pretrained_embeddings/chinese_L-12_H-768_A-12/vocab.txt' ,
bert_config_file = 'pretrained_embeddings/chinese_L-12_H-768_A-12/bert_config.json' ,
bert_checkpoint_file = 'pretrained_embeddings/chinese_L-12_H-768_A-12/bert_model.ckpt' ,
bert_trainable = False ,
optimizer = 'adam' ,
callback_list = [ 'modelcheckpoint' , 'earlystopping' , 'swa' ],
checkpoint_dir = 'pretrained_models' ,
model_name = 'msra_ner_bilstm_cnn_bert_crf' ,
load_swa_model = True )No trecho de código acima, é importante observar:
ner_model_type : Defina o tipo de modelo como bilstm_cnn , e um modelo não-Bert deve ser usado aqui;use_char : defina para não usar vetores no nível do caractere;use_word : defina para não usar vetores de nível de palavra como entrada auxiliar;use_bert : defina para usar apenas vetores Bert como entrada de recursos;bert_vocab_file , bert_config_file , bert_checkpoint_file : o caminho para os arquivos relacionados ao modelo BERTbert_trainable : Defina o parâmetro do modelo BERT como um estado não preenchido, e também é possível defini -lo como True aqui;optimizer : defina o otimizador. Se o modelo BET for treinável, é recomendável ajustar a taxa de aprendizado do otimizador a um menor. import tensorflow as tf
from fancy_nlp . applications import NER
ner_app = NER ( use_pretrained = False )
from fancy_nlp . utils import load_ner_data_and_labels
train_data , train_labels = load_ner_data_and_labels ( 'datasets/ner/msra/train_data' )
valid_data , valid_labels = load_ner_data_and_labels ( 'datasets/ner/msra/test_data' )
ner_app . fit ( train_data , train_labels , valid_data , valid_labels ,
ner_model_type = 'bilstm_cnn' ,
use_char = True ,
use_word = False ,
use_bert = True ,
bert_vocab_file = 'pretrained_embeddings/chinese_L-12_H-768_A-12/vocab.txt' ,
bert_config_file = 'pretrained_embeddings/chinese_L-12_H-768_A-12/bert_config.json' ,
bert_checkpoint_file = 'pretrained_embeddings/chinese_L-12_H-768_A-12/bert_model.ckpt' ,
bert_trainable = True ,
optimizer = tf . keras . optimizers . Adam ( 1e-5 ),
callback_list = [ 'modelcheckpoint' , 'earlystopping' , 'swa' ],
checkpoint_dir = 'pretrained_models' ,
model_name = 'msra_ner_bilstm_cnn_char_bert_crf' ,
load_swa_model = True )No trecho de código acima, é importante observar:
ner_model_type : Defina o tipo de modelo como bilstm_cnn , e um modelo não bert deve ser usado aqui;use_char : defina o vetor de uso de caracteres;use_word : defina para não usar vetores de nível de palavra como entrada auxiliar;use_bert : defina o uso do vetor Bert, que combina vetores de palavras e vetores Bert como entradas de recursos;bert_vocab_file , bert_config_file , bert_checkpoint_file : o caminho para os arquivos relacionados ao modelo BERTbert_trainable : Defina os parâmetros do modelo BERT como estado treinável, e também é possível defini -lo como False aqui;optimizer : defina o otimizador. Se o modelo BET for treinável, é recomendável ajustar a taxa de aprendizado do otimizador a um menor. Os desenvolvedores que estão interessados em melhorar o código de PNL sofisticado devem seguir as seguintes especificações para enviar solicitações de puxar:
Se você usar a PNL sofisticada durante o processo de pesquisa relacionado, poderá adicionar o seguinte à lista de citações
@misc{tencent2019fancynlp,
title={Fancy-NLP},
author={Li Yang and Shiyao Xu and Shijia E},
howpublished={ url {https://github.com/boat-group/fancy-nlp}},
year={2019}
}▴ de volta ao topo
Este projeto é inspirado em muitos excelentes projetos de código aberto, especialmente Keras. Como disse o slogan de Keras: o aprendizado profundo para o humano disse, esperamos que a PNL é a PNL para a Human , especialmente no campo chinês.
